├── .gitignore ├── Performance Data.xlsx ├── README.md ├── README_OLD.md ├── img ├── cubepattern.png ├── cubepatternsolid.png ├── cutout.png ├── demo.aep ├── donutshatter.png ├── errors │ ├── clip.png │ ├── clip_correct.png │ └── icosphere.jpg ├── fracture1.jpg ├── fracture_demo.mp4 ├── fracturepattern.png ├── hulledges.png ├── hullpoints.png ├── manyshatter.png ├── parallelalg.png ├── parallelalg.svg ├── performance │ ├── cpu_gpu_fracture.png │ ├── cubicvr_time.png │ ├── p_s_intersection.png │ ├── stream_compact_sequential.png │ └── webcl_cpu_gpu.png ├── shadow.png ├── wallshatter.png ├── wallwireframe.png ├── wireframe.png └── youtube.png ├── src ├── CubicVR_Core.fs ├── CubicVR_Core.vs ├── cl │ └── fracture.cl ├── index.html ├── index_old.html ├── js │ ├── CubicVR.min.js │ ├── fracturecl.js │ ├── main.js │ └── ourmath.js ├── lib │ ├── CubicVR.js │ ├── ammo.fast.js │ ├── ammo.js │ ├── stats.js │ └── stats.min.js └── models │ ├── asteroids1.dae │ ├── cube.dae │ ├── cubeshatter.blend │ ├── cubeshatter.dae │ ├── donut.blend │ ├── donut.dae │ ├── icoshatter.blend │ ├── icoshatter.dae │ ├── icosphere.dae │ ├── oct.blend │ ├── oct.dae │ ├── slice.dae │ ├── tet.dae │ ├── tet1.dae │ ├── wall.blend │ ├── wall.dae │ └── wall3.dae └── testanalysis.blend /.gitignore: -------------------------------------------------------------------------------- 1 | *.blend1 2 | *.swp 3 | -------------------------------------------------------------------------------- /Performance Data.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/Performance Data.xlsx -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # This project doesn't work anymore. Please see the [port to WebGPU](https://github.com/kainino0x/webgpu-fracture-hack). 2 | 3 | # GPU-Accelerated Dynamic Fracture in the Browser - CIS 565 Final Project 4 | 5 | Fall 2014 6 | 7 | Jiatong He, Kai Ninomiya 8 | 9 | ![](https://github.com/kainino0x/cis565final/blob/master/img/manyshatter.png) 10 | 11 | [![Demo Video on YouTube](img/youtube.png)](https://www.youtube.com/watch?v=13sbZia4Kjc) 12 | 13 | Our goal was to create a gpu-accelerated interactive real-time mesh fracture application that runs in the browser. We used WebCL to parallelize the algorithm and CubicVR to render and simulate the rigid bodies. 14 | 15 | ~~[Live Demo](https://kainino0x.github.io/cis565final/src/): 16 | requires the [Nokia WebCL plugin](http://webcl.nokiaresearch.com/) for Firefox.~~ (EDIT 2018 Feb: WebCL is dead. In fact, it was already dead when we started this project. If you're lucky, you may still get this demo to work, but I don't recommend putting in the effort.) 17 | 18 | >**Controls** 19 | > 20 | >`click + drag` : Rotate camera view 21 | > 22 | >`alt + click + drag` : Pan camera view 23 | > 24 | >`mouse scroll` : Zoom camera 25 | > 26 | >`click on object + drag` : Move selected object around 27 | > 28 | >`click + drag` : Rotate camera view 29 | > 30 | >`F + click on object` : Fracture object 31 | > 32 | >`W + click` : Toggle wireframe 33 | > 34 | >`D + click` : Toggle fracture pattern 35 | 36 | _Based on 37 | [Real Time Dynamic Fracture with Volumetric Approximate Convex Decompositions](https://www.graphics.rwth-aachen.de/media/teaching_files/mueller_siggraph12.pdf) 38 | by Müller, Chentanez, and Kim._ 39 | 40 | ## Table of Contents 41 | * [Algorithm Overview](#algorithm-overview) 42 | * [Fracturing](#fracturing) 43 | * [Alignment](#alignment) 44 | * [Intersection](#intersection) 45 | * [Welding](#welding) 46 | * [Island Detection](#island-detection) 47 | * [Partial Fracture](#partial-fracture) 48 | * [Implementation Details](#implementation-details) 49 | * [Fracturing](#fracturing-1) 50 | * [Intersection](#intersection-1) 51 | * [Stream Compaction](#stream-compaction) 52 | * [Partial Fracture](#partial-fracture-1) 53 | * [Working with WebCL](#working-with-webcl) 54 | * [WebCL Performance Issues](#webcl-performance-issues) 55 | * [Integration into an Existing Renderer/Rigid Body Simulator](#integration-into-an-existing-rendererrigid-body-simulator-cubicvr) 56 | * [Performance Analysis](#performance-analysis) 57 | * [Fracture Performance](#fracture-performance) 58 | * [Intersection: GPU vs. CPU, Parallel vs. Sequential](#intersection-gpu-vs-cpu-parallel-vs-sequential) 59 | * [Stream Compaction: Parallel vs. Sequential](#stream-compaction-parallel-vs-sequential) 60 | * [WebCL Performance](#webcl-performance) 61 | * [CubicVR's Limits in Real-Time Simulation](#cubicvrs-limits-in-real-time-simulation) 62 | 63 | ## Algorithm Overview 64 | ### Fracturing 65 | At a high level, fracturing is implemented by performing boolean intersection 66 | between segments of a fracture pattern and the segments of the object to be 67 | fractured. The fracture pattern can be pre-generated, as is the case for our implementation. 68 | 69 | ![](https://github.com/kainino0x/cis565final/blob/master/img/cubepattern.png) 70 | 71 | _A pre-generated test fracture pattern (series of solid meshes):_ 72 | 73 | #### Alignment 74 | The first step is to align the fracture pattern with the point of impact. 75 | 76 | ![](https://github.com/kainino0x/cis565final/blob/master/img/cutout.png) 77 | 78 | _The wireframe is the impacted mesh, the solid is the fracture pattern_ 79 | 80 | We use the point the user clicks on the object as the point of impact, and transform the fracture mesh appropriately (all meshes are centered at 0,0,0). 81 | 82 | #### Intersection 83 | The mesh must then be intersected with the fracture mesh, resulting in one shard per cell of the fracture pattern. A simple way to do this is to clip the mesh against each face of the cell, for each cell in the fracture pattern. 84 | 85 | ![](https://github.com/kainino0x/cis565final/blob/master/img/cubepatternsolid.png) 86 | 87 | _A solid render of the 3D fracture pattern we are using_ 88 | 89 | #### Welding* 90 | If a shard completely fills a cell, then it can be replaced with the cell's geometry. This reduces the number of triangles produced by the intersection. 91 | 92 | #### Island Detection* 93 | If a clipping cell results in disconnected pieces within a cell, island detection should be used to split those pieces into multiple shards, instead of just one. That way you won't have disconnected pieces moving together as though they were one mesh. 94 | 95 | ### Partial Fracture 96 | Partial fracture occurs if we limit the area of effect of the fracture to some distance around the point of impact. 97 | 98 | ![](https://github.com/kainino0x/cis565final/blob/master/img/wallshatter.png) 99 | 100 | _Notice how the bottom and right sides of the wall stay intact while the upper-left is fractured_ 101 | 102 | Rather than allowing the entire mesh to be fractured, we only fully shard the cells within the area of effect. Shards in cells outside of the area of effect can be merged together back into a single mesh. 103 | 104 | _\* : not implemented._ 105 | 106 | ## Implementation Details 107 | ![](https://github.com/kainino0x/cis565final/blob/master/img/donutshatter.png) 108 | 109 | _A fractured torus_ 110 | 111 | ### Fracturing 112 | The fracturing algorithm was our greatest challenge. It's an algorithm that is naturally sequential--clipping polygons usually requires some knowledge of neighbors and other information. However, we devised a method that successfully targets independent pieces of the algorithm at the cost of some accuracy. 113 | #### Intersection 114 | Our intersection algorithm is simple clipping planes. For each cell, the mesh is clipped by each cell face to give us the shard. What's interesting is how we parallelized it. 115 | ##### Parallelization 116 | Our strategy for the parallelization of the intersection was to treat the mesh as a set of disconnected triangles. By doing so, we could parallelize by-cell-by-triangle. 117 | 118 | ![](https://github.com/kainino0x/cis565final/blob/master/img/parallelalg.png) 119 | 120 | _Diagram of the parallel algorithm we used to clip meshes_ 121 | 122 | For each face of the cell, we clip each triangle in the mesh by that face independently, then create the new faces for them. We can process all cells at once, and iterate a total number of times equal to the maximum number of faces in a single cell. 123 | 124 | #### Stream Compaction 125 | Our implementation uses stream compaction to remove culled triangles each iteration in order to keep the number of triangles under control (otherwise it could grow at a rate of 2^n). We tried both a sequential and a parallel version of this algorithm to see which one was better. The sequential implementation simply iterates through the list and pushes non-culled objects into a new array. 126 | ##### Parallelization 127 | The reason we wanted to do stream compaction on the GPU was to reduce the amount of memory transfer between CPU and GPU. Each time our plane clipping kernel returned, we would need to copy the entire output back onto the CPU, remove bad values, add new faces, and put everything back into the GPU. If stream compaction were parallelized, we would not have that problem. 128 | 129 | We implemented stream compaction in WebCL, but ran into some performance issues that made it much slower than the copy+process on CPU method. As a result, we abandoned the stream compaction (the code is still in the stream-compaction branch) and are now removing bad values sequentially. The performance analysis section furhter below contains more details about this issue. 130 | 131 | #### Partial Fracture 132 | This feature is noteworthy because we technically cheated this one. Instead of properly combining faces, or doing some processing, we just group all the fragments that are not in the area of effect into a single mesh. This means that said mesh will have: 1, several times more geometry than other fragments, 2, faces inside of the mesh, and 3, slightly overlapping/disconnected edges on the surface. 133 | 134 | ![](https://github.com/kainino0x/cis565final/blob/master/img/wallwireframe.png) 135 | 136 | _The body on the upper-left is the merged mesh. See how its individual components are clearly visible in the wireframe?_ 137 | 138 | ### Working with WebCL 139 | Because our target was an in-browser experience, we were limited to two choices for GPU-acceleration: WebGL and WebCL. While WebGL runs natively in most browsers, it does not yet support compute shaders as of this time, so we would have had to hack a solution using textures and feedbacks. WebCL, on the other hand, is supported by **no** browsers, but Nokia has a plugin that can run it. We chose to use WebCL for its flexibility compared to WebGL. 140 | #### WebCL Performance Issues 141 | We did, however, run into some performance issues with WebCL that were severe enough that a GPU stream compaction was slower than a sequential javascript method. You can see a comparison between the two in the Performance Analysis section. In addition, we logged the runtimes of individual set args, read/write, and kernel calls to show how slow it actually is. 142 | 143 | ### Integration into an Existing Renderer/Rigid Body Simulator (CubicVR) 144 | Because our main focus was creating the fractured geometry, we looked for an existing renderer and rigid body simulator. CubicVR (physics built on ammo.js, which is compiled from bullet) provides a very simple-to-use library for both, though we ran into some issues here as well. The performance issues we had with usingCubicVR are detailed in the Performance Analysis section of the readme. 145 | 146 | 147 | ## Performance Analysis 148 | 149 | Performance measurements were taken on one of the following setups. (Performance comparisons are on one machine.) 150 | 151 | * Arch Linux, Intel i5-4670 + NVIDIA GTX 750 (CPU/GPU comparisons) 152 | * Windows 8.1, Intel i7-4700HQ (CPU-only measurements) 153 | 154 | ### Fracture Performance 155 | We began to implement fracture using a naive sequential algorithm as a proof-of-concept. The algorithm runs somewhat differently compared to the parallel algorithm (it sequentially does the clipping planes on the entire mesh, and keeps the mesh closed), but it's nice as a basis of comparison. 156 | #### Intersection: GPU vs. CPU, Parallel vs. Sequential 157 | We compared the runtime of our code on the GPU vs. the CPU, as well as the parallel and sequential implementations of the intersection. 158 | 159 | ![](https://github.com/kainino0x/cis565final/blob/master/img/performance/cpu_gpu_fracture.png) 160 | 161 | _Runtime of the fracture algorithm on the CPU compared to the GPU_ 162 | 163 | The main thing to notice here is that the CPU and GPU times are nearly identical. We have no explanation for why reads/writes have the same runtime, as well as kernels. It may just be an issue with a data set that's too small. 164 | 165 | ![](https://github.com/kainino0x/cis565final/blob/master/img/performance/p_s_intersection.png) 166 | 167 | _Runtime of the parallel algorithm compared a naive sequential version_ 168 | 169 | Ignoring the part of the parallel graph where it starts to dip down, it's generally clear that the parallel algorithm does not scale very quickly with increasing triangle count, while the sequential algorithm begins taking far more time with each step. While this graph does not show it, the sequential implementation quickly surpasses the parallel implementation in runtime with higher number of triangles, as expected. 170 | 171 | 172 | ### Stream Compaction: Parallel vs. Sequential 173 | Each time we clip a plane-per-cell from the set of triangles, we're left with a lot of culled triangles that can be removed to keep memory costs low. We implemented both a sequential remove (iterating through and adding valid triangles to another array) and a parallel stream compaction. The sequential remove requires copying memory back onto the CPU, then performing the remove in javascript, while the stream compaction keeps everything on the GPU. 174 | 175 | ![](https://github.com/kainino0x/cis565final/blob/master/img/performance/stream_compact_sequential.png) 176 | 177 | _Runtime of the stream compaction algorithm vs. a sequential remove_ 178 | 179 | Strangely enough, the stream compaction (though a naive implementation) performs far worse than the sequential remove, which requires a lot of back-and-forth between the CPU and GPU. We weren't sure what was causing this, so we investigated the performance of WebCL to see if that was the issue (Stream Compaction makes a LOT of webCL calls). 180 | 181 | ### WebCL Performance 182 | 183 | ![](https://github.com/kainino0x/cis565final/blob/master/img/performance/webcl_cpu_gpu.png) 184 | 185 | _WebCL runtimes on the GPU and CPU. Note how they are nearly identical_ 186 | 187 | As expected from the Intersection performance analysis, the GPU and CPU calls are actually nearly identical. The only possible error is in the "Run Kernel" values in each, since they may be affected by our worksize setup. The runtimes of each of the other calls average to around 0.8ms each. This quickly adds up when you need to make somee 50 of these calls for each face-per-cell, along with running the actual kernel. We suspect that the poor performance of the parallel algorithms are due to this slower runtime. 188 | 189 | ### CubicVR's Limits in Real-Time Simulation 190 | 191 | CubicVR posed some challenges to our simulation, specifically in how our fragmented shards were added to the scene. The main factor is computing the collision detection surface on each of the shards. Using a convex hull collision, the processing time from CubicVR was far higher (~80% of the total time) than the time taken during our algorithm. However, convex hull collisions ran quickly in the simulator. In order to prevent long freezes, we switched over to mesh collision ang got the following results: 192 | 193 | ![](https://github.com/kainino0x/cis565final/blob/master/img/performance/cubicvr_time.png) 194 | 195 | _CubicVR's contribution to the total time of our algorithm_ 196 | 197 | Now CubicVR is no longer the source of the bottleneck of our algorithm, but mesh collision runs much more slowly than convex hull collision. 198 | 199 | The issue here is the large number of triangles we are generating. Convex hulls take a long time to calculate for meshes with large triangle counts. We can reduce the calculation time by implementing optimizations that reduce the geometry for each shard (they end up with far more faces than is necessar) such as the "welding" step. 200 | 201 | ## References 202 | 203 | [1] Matthias Müller, Nuttapong Chentanez, and Tae-Yong Kim. 2013. 204 | Real time dynamic fracture with volumetric approximate convex decompositions. 205 | ACM Trans. Graph. 32, 4, Article 115 (July 2013), 10 pages. 206 | DOI=10.1145/2461912.2461934 http://doi.acm.org/10.1145/2461912.2461934 207 | 208 | [2] stats.js. Copyright 2009-2012 Mr.doob. Used under MIT License. 209 | https://github.com/mrdoob/stats.js 210 | 211 | [3] CubicVR 3D Engine. Javascript Port of the CubicVR 3D Engine by Charles J. Cliffe. 212 | Used under MIT License. 213 | https://github.com/cjcliffe/CubicVR.js 214 | 215 | [4] ammo.js. A direct port of the Bullet physics engine to JavaScript, using Emscripten. 216 | Used under zlib License. 217 | https://github.com/kripken/ammo.js 218 | -------------------------------------------------------------------------------- /README_OLD.md: -------------------------------------------------------------------------------- 1 | CIS565: Final Project -- GPU-Accelerated Dynamic Real-Time Fracture in the Browser 2 | =========== 3 | Fall 2014 4 | ----------- 5 | Jiatong He, Kai Ninomiya 6 | ----------- 7 | 8 | [Live demo](https://kainino0x.github.io/cis565final/src/): 9 | requires the [Nokia WebCL plugin](http://webcl.nokiaresearch.com/) for Firefox. 10 | 11 | Based on 12 | [Real Time Dynamic Fracture with Volumetric Approximate Convex Decompositions](https://www.graphics.rwth-aachen.de/media/teaching_files/mueller_siggraph12.pdf) 13 | by Müller, Chentanez, and Kim. 14 | 15 | Algorithm Overview 16 | ----------------- 17 | ###Fracturing 18 | At a high level, fracturing is implemented by performing boolean intersection 19 | between segments of a fracture pattern and the segments of the object to be 20 | fractured. More information on the method is found in Mueller's paper (above). 21 | 22 | A pre-generated test fracture pattern (series of solid meshes): 23 | 24 | ![](img/fracturepattern.png) 25 | 26 | ##Checklist 27 | ####Part 1 28 | * Set up codebase (Turbulenz?) 29 | * Get a working rigid body simulator 30 | * Integrate simple webCL (eg. shift mesh's colors) 31 | * Generate some 3D Voronoi decomposition 32 | * Find and highlight intersections with simple mesh (eg glass panel) 33 | 34 | ##TODO 35 | * ~~Parallel implementation of plane-triangle clipping.~~ 36 | * ~~use webCL to create a copy of the input mesh for each fracture cell.~~ 37 | * webCL implementation of stream compaction (used in intersection). 38 | * webCL implementation of makeFaces() (needs webCL scan). 39 | * ~~correct orientation/center of fracture pieces.~~ 40 | * ~~center the fracture pattern on point of impact.~~ 41 | * ~~sew fractured pieces back together based on proximity to point of impact.~~ 42 | * scale fracture patterns up to the mesh geometry(or generate sufficiently large ones) (or generate one with a single outer cell whose fac normals all point outwards?) 43 | * ~~Find the correct center of meshes (for better RBD in bullet)~~ 44 | * correctly handle concave surfaces (island detection). 45 | * ~~Modify linear velocity based on direction and distance from impact point.~~ 46 | * Optimization: Welding step (replace fragments with cell mesh if the fragment completely fills the cell). 47 | * Optimization: detecting collinear edges and merging their faces 48 | * performance testing, profiling, other optimizations. 49 | 50 | ##Progress 51 | ###Part 1 52 | ####Setting up the codebase 53 | We initially began with Turbulenz, since it seemed like the most powerful engine available and combined the rigid body physics we needed with a renderer. However, it was difficult to work with the convex hulls we wanted, so we switched to CubicVR.js, an open-source 3d engine that uses ammo.js for physics. 54 | 55 | Based on our experience so far, we will probably switch to using mesh 56 | representations instead of specialized convex hull representations, due to the 57 | more useful properties of meshes. Given this switch, it's possible we'll also 58 | move back to Turbulenz or another engine. 59 | 60 | ####Working Rigid Body Simulator 61 | This was very easy to set up with CubicVR/Ammo (using one of the CubicVR 62 | provided examples), and was completed quickly. 63 | 64 | ####WebCL 65 | Currently not implemented due to our focus on getting a working engine and demo 66 | 67 | ####3D Voronoi Decomposition as fracture pattern 68 | This one turned out to be a little tricky because we didn't find a javascript implementation of 3d voronoi decomposition. We plan on making a library for it later, but for testing, we are using a voronoi decomposition made from Blender. Blender has the ability to generate a voronoi decomposition from a set of points, which is good enough for us to use as a constant, pregenerated fracture pattern. This is saved to a .dae file and read in as a set of meshes (cells). 69 | 70 | ####Intersection Testing 71 | Intersection testing was difficult to solve because we were somewhat limited by the structures available to us through the CubicVR engine. We spent some time figuring out the method to handle the cell-mesh intersections, which was more difficult than expected due to some limits in the libraries we used. 72 | 73 | The most significant one is that Bullet's btConvexHullComputer, which computes a convex hull mesh based on a set of points, seems to be unavailable in ammo.js. 74 | This means that we would need to calculate our own convex hull mesh, or work entirely in convex hulls, which would result in some necessary approximations for the geometry. 75 | 76 | Due to these limitations with the convex hull data exposed by Ammo.js, our next 77 | approach will be to do our operations directly on the meshes. In order to move 78 | forward, we plan to perform the fracture computations directly on mesh data 79 | (either an existing CubicVR structure or another simple implementation). 80 | 81 | ##Debug images 82 | 83 | The set of points on the the original object 84 | (which is all that the btConvexHullShape stores): 85 | 86 | ![](img/hullpoints.png) 87 | 88 | The set of edges returned by the Bullet btConvexHullShape object 89 | (also not so useful!): 90 | 91 | ![](img/hulledges.png) 92 | 93 | ##Paralelization of the Intersection Algorithm 94 | ###Initial Thoughts 95 | The intersection algorithm is the first point of paralelization. Each fracture cell can be processed onto the mesh independently, which means that we can first paralelize by cell. Within each cell, each plane of the cell needs to be used as a clipping plane to then clip against the mesh. This will likely be a bottleneck for the code, since clipping planes will need to be run sequentially. 96 | 97 | Note that the current algorithm assumes a triangulated mesh. 98 | 99 | The intersection algorithm outline looks to be as follows: 100 | 101 | ``` 102 | setupClipMesh(); 103 | 104 | For each fracture cell: 105 | For each face of the fracture cell: 106 | // perform clipping plane algorithm. Based on the algorithm described at 107 | // http://www.geometrictools.com/Documentation/ClipMesh.pdf 108 | clipVertices(); // mark vertices as culled or passed. 109 | clipEdges(); // mark edges as culled, intersecting, or passed. 110 | clipFaces(); // mark faces as culled or passed, update faces based on edges. Create new faces/edges if necessary to maintain triangulation. 111 | end for 112 | end for 113 | 114 | rebuildMeshes(); // Parse through the vertex and face arrays and keep the unclipped ones, updating indices. 115 | ``` 116 | 117 | clipFaces() is a little more work than the others. The core of the algorithm is: 118 | * Update the faces whose edges are partially clipped. 119 | * Generate new edges along the plane 120 | * Generate faces to cover those new edges. This face will be coplanar to the clipping plane. 121 | 122 | There are four cases that can occur for faces: 123 | * 1. all edges are above the clipping plane (no change). 124 | * 2. all edges are below the clipping plane (face gets removed). 125 | * 3. one edge is above, two intersect the clipping plane (this intersection forms a quad so we need to create two new edges and one new face). 126 | * 4. one edge is below, two intersect the clipping plane (this intersection forms a triangle so we only need to add in one new edge). 127 | 128 | Some issues are immediately clear: 129 | * Different amounts of processing will be required for different cells/planes. This varies depending primarily on the number of faces in a cell. 130 | * Different amounts of memory will be needed for different cells/planes. It is not immediately clear how many new vertices and faces a clipping plane will create. Do we need to overcompensate and assume the worst-case scenario every time? This will likely become the main concern. 131 | * We need to adapt the presented algorithm to be able to handle multiple sequential clipping planes. This should be straightforward since new vertices, edges, and faces are added into the list. 132 | * What happens when the fracture pattern does not completely cover the mesh? do we scale it up so that it encloses the bounding box? Do we need to handle outside pieces in a special way? 133 | 134 | Some optimizations can be made: 135 | * The fracture pattern can be stored as a non-triangulated mesh. That is, each face is in its own plane. This way there is no need to calculate the minimum number of clipping planes necessary. 136 | * What if we optimized by vertex-face-edge : plane intersection as opposed to cell-by-cell? 137 | 138 | Keeping these issues in mind, we came up with a new way to parallelize the intersection algorithm: 139 | ###Chosen Algorithm 140 | The goal of this algorithm was to find a method to clip meshes that had the least amount of dependence between units. With this in mind, we came up with the following: 141 | 142 | Our code now parallelizes on a per-clipping-face-per-mesh-triangle level. We run one clipping plane per cell on each triangle in the mesh per loop iteration, iterating through the list of clipping planes per cell. 143 | 144 | One key feature is that we no longer handle the mesh as a whole (we still keep track), but as a set of unrelated triangles. We take this triangle "soup" and run it through the algorithm, getting new triangles with each iteration. These triangles can be connected by merging identical points at the end of the algorithm if a closed mesh is desired, but disconnected triangles works for our purposes. 145 | 146 | The loop runs for max(#cellfaces) iterations. The kernel processes a triangle-clipping plane pair with a cell number attached to it, and returns a list of triangles and a list of new points. We take this list and generate a set of new triangles to add to the list, and reiterate. 147 | 148 | ###Concave Plane Intersections 149 | How to handle? Centroid connection does not work! 150 | 151 | Edge loops? 152 | 153 | ##Stream Compaction 154 | In order to reduce gpu-cpu memory transfer. 155 | 156 | ##Island Detection 157 | Low priority, necessary both before and after partial fracture. If implemented, then partial fracture needs to be in its own kernel or loop. 158 | 159 | ##Partial Fracture 160 | ###Algorithm: 161 | * label each cell as "affected" or "not affected" 162 | * after the intersection algorithm runs, combine all "not affected" fracture pieces into a single mesh (for our purposes, put them all into a single cell) 163 | * (optional) perform island detection on that mesh 164 | -------------------------------------------------------------------------------- /img/cubepattern.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/cubepattern.png -------------------------------------------------------------------------------- /img/cubepatternsolid.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/cubepatternsolid.png -------------------------------------------------------------------------------- /img/cutout.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/cutout.png -------------------------------------------------------------------------------- /img/demo.aep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/demo.aep -------------------------------------------------------------------------------- /img/donutshatter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/donutshatter.png -------------------------------------------------------------------------------- /img/errors/clip.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/errors/clip.png -------------------------------------------------------------------------------- /img/errors/clip_correct.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/errors/clip_correct.png -------------------------------------------------------------------------------- /img/errors/icosphere.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/errors/icosphere.jpg -------------------------------------------------------------------------------- /img/fracture1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/fracture1.jpg -------------------------------------------------------------------------------- /img/fracture_demo.mp4: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/fracture_demo.mp4 -------------------------------------------------------------------------------- /img/fracturepattern.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/fracturepattern.png -------------------------------------------------------------------------------- /img/hulledges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/hulledges.png -------------------------------------------------------------------------------- /img/hullpoints.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/hullpoints.png -------------------------------------------------------------------------------- /img/manyshatter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/manyshatter.png -------------------------------------------------------------------------------- /img/parallelalg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/parallelalg.png -------------------------------------------------------------------------------- /img/parallelalg.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 21 | 23 | 41 | 55 | 56 | 58 | 59 | 61 | image/svg+xml 62 | 64 | 65 | 66 | 67 | 68 | 73 | 79 | 86 | 93 | 100 | 130 | 137 | 144 | 147 | 152 | 157 | 162 | 163 | 166 | 171 | 176 | 181 | 182 | 185 | 190 | 195 | 200 | 201 | create onecopy of theoriginalmesh foreach cell(each finaltarget shard) 243 | array of the firstclip plane of each cell 260 | array of the secondclip plane of each cell 277 | clip againstcell 1 plane 1 292 | clippingplane arrays(calculate once) 312 | clip againstcell 2 plane 1 327 | clip againstcell 3 plane 1 342 | 348 | clip againstcell 1 plane 2 363 | clip againstcell 2 plane 2 378 | clip againstcell 3 plane 2 393 | 400 | 407 | 414 | 417 | 422 | 427 | 428 | 431 | 436 | 441 | 446 | 447 | 450 | 455 | 460 | 461 | 468 | 475 | 482 | 485 | 490 | 495 | 496 | 499 | 504 | 509 | 510 | 513 | 523 | 533 | 543 | 544 | 545 | 546 | -------------------------------------------------------------------------------- /img/performance/cpu_gpu_fracture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/performance/cpu_gpu_fracture.png -------------------------------------------------------------------------------- /img/performance/cubicvr_time.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/performance/cubicvr_time.png -------------------------------------------------------------------------------- /img/performance/p_s_intersection.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/performance/p_s_intersection.png -------------------------------------------------------------------------------- /img/performance/stream_compact_sequential.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/performance/stream_compact_sequential.png -------------------------------------------------------------------------------- /img/performance/webcl_cpu_gpu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/performance/webcl_cpu_gpu.png -------------------------------------------------------------------------------- /img/shadow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/shadow.png -------------------------------------------------------------------------------- /img/wallshatter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/wallshatter.png -------------------------------------------------------------------------------- /img/wallwireframe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/wallwireframe.png -------------------------------------------------------------------------------- /img/wireframe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/wireframe.png -------------------------------------------------------------------------------- /img/youtube.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/img/youtube.png -------------------------------------------------------------------------------- /src/CubicVR_Core.fs: -------------------------------------------------------------------------------- 1 | #ifdef GL_ES 2 | #if LIGHT_PERPIXEL 3 | precision mediump float; 4 | #else 5 | precision lowp float; 6 | #endif 7 | #endif 8 | 9 | #if FOG_ENABLED 10 | uniform vec3 fogColor; 11 | uniform float fogDensity; 12 | 13 | uniform float fogNear; 14 | uniform float fogFar; 15 | #endif 16 | 17 | uniform vec3 materialAmbient; 18 | uniform vec3 lightAmbient; 19 | uniform vec3 materialColor; 20 | 21 | #if POINT_SIZE && !POINT_SPRITE && POINT_CIRCLE 22 | varying float ptSize; 23 | varying vec2 sPos; 24 | #endif 25 | 26 | #if LIGHT_PERPIXEL 27 | 28 | uniform vec3 materialDiffuse; 29 | uniform vec3 materialSpecular; 30 | uniform float materialShininess; 31 | 32 | #if LIGHT_IS_POINT||LIGHT_IS_DIRECTIONAL||LIGHT_IS_SPOT||LIGHT_IS_AREA 33 | uniform vec3 lightDirection[LIGHT_COUNT]; 34 | uniform vec3 lightPosition[LIGHT_COUNT]; 35 | uniform vec3 lightSpecular[LIGHT_COUNT]; 36 | uniform vec3 lightDiffuse[LIGHT_COUNT]; 37 | uniform float lightIntensity[LIGHT_COUNT]; 38 | uniform float lightDistance[LIGHT_COUNT]; 39 | #if LIGHT_IS_SPOT 40 | uniform float lightCutOffAngle[LIGHT_COUNT]; 41 | #endif 42 | #endif 43 | 44 | #if LIGHT_IS_PROJECTOR 45 | uniform sampler2D lightProjectionMap[LIGHT_COUNT]; 46 | #endif 47 | 48 | #if LIGHT_SHADOWED 49 | varying vec4 lightProjectionOut[LIGHT_COUNT]; 50 | uniform sampler2D lightShadowMap[LIGHT_COUNT]; 51 | uniform vec3 lightDepthClip[LIGHT_COUNT]; 52 | #endif 53 | 54 | #else // !LIGHT_PERPIXEL 55 | varying vec3 lightColorOut; 56 | varying vec3 lightSpecularOut; 57 | 58 | #endif // LIGHT_PERPIXEL 59 | 60 | varying vec3 vertexNormalOut; 61 | varying vec2 vertexTexCoordOut; 62 | 63 | #if VERTEX_COLOR 64 | varying vec3 vertexColorOut; 65 | #endif 66 | 67 | #if FX_DEPTH_ALPHA||LIGHT_DEPTH_PASS||LIGHT_SHADOWED 68 | 69 | uniform vec3 postDepthInfo; 70 | float ConvertDepth3(float d) { return (postDepthInfo.x*postDepthInfo.y)/(postDepthInfo.y-d*(postDepthInfo.y-postDepthInfo.x)); } 71 | // transform range in world-z to 0-1 for near-far 72 | float DepthRange( float d ) { return ( d - postDepthInfo.x ) / ( postDepthInfo.y - postDepthInfo.x ); } 73 | 74 | float ConvertDepth3A(float d, float near, float far) { return (near*far)/(far-d*(far-near)); } 75 | // transform range in world-z to 0-1 for near-far 76 | float DepthRangeA( float d, float near, float far ) { return ( d - near ) / ( far - near ); } 77 | #endif 78 | 79 | #if LIGHT_DEPTH_PASS 80 | vec4 packFloatToVec4i(const float value) 81 | { 82 | const vec4 bitSh = vec4(256.0*256.0*256.0, 256.0*256.0, 256.0, 1.0); 83 | const vec4 bitMsk = vec4(0.0, 1.0/256.0, 1.0/256.0, 1.0/256.0); 84 | vec4 res = fract(value * bitSh); 85 | res -= res.xxyz * bitMsk; 86 | return res; 87 | } 88 | 89 | #endif 90 | 91 | #if LIGHT_SHADOWED 92 | float unpackFloatFromVec4i(const vec4 value) 93 | { 94 | const vec4 bitSh = vec4(1.0/(256.0*256.0*256.0), 1.0/(256.0*256.0), 1.0/256.0, 1.0); 95 | return(dot(value, bitSh)); 96 | } 97 | 98 | #if LIGHT_SHADOWED_SOFT 99 | float getShadowVal(sampler2D shadowTex,vec4 shadowCoord, float proj, float texel_size) { 100 | vec2 filterTaps[6]; 101 | filterTaps[0] = vec2(-0.326212,-0.40581); 102 | filterTaps[1] = vec2(-0.840144,-0.07358); 103 | filterTaps[2] = vec2(-0.695914,0.457137); 104 | filterTaps[3] = vec2(-0.203345,0.620716); 105 | filterTaps[4] = vec2(0.96234,-0.194983); 106 | filterTaps[5] = vec2(0.473434,-0.480026); 107 | 108 | /* filterTaps[6] = vec2(0.519456,0.767022); 109 | filterTaps[7] = vec2(0.185461,-0.893124); 110 | filterTaps[8] = vec2(0.507431,0.064425); 111 | filterTaps[9] = vec2(0.89642,0.412458) ; 112 | filterTaps[10] =vec2(-0.32194,-0.932615); 113 | filterTaps[11] =vec2(-0.791559,-0.59771); */ 114 | 115 | float shadow = 0.0; 116 | vec4 shadowSample; 117 | float distanceFromLight; 118 | 119 | for (int i = 0; i < 6; i++) { 120 | shadowSample = texture2D(shadowTex,shadowCoord.st+filterTaps[i]*(2.0*texel_size)); 121 | 122 | distanceFromLight = unpackFloatFromVec4i(shadowSample); 123 | 124 | shadow += distanceFromLight <= shadowCoord.z ? 0.0 : 1.0 ; 125 | } 126 | 127 | shadow /= 6.0; 128 | 129 | return shadow; 130 | } 131 | #else 132 | float getShadowVal(sampler2D shadowTex,vec4 shadowCoord, float proj, float texel_size) { 133 | vec4 shadowSample = texture2D(shadowTex,shadowCoord.st); 134 | 135 | float distanceFromLight = unpackFloatFromVec4i(shadowSample); 136 | float shadow = 1.0; 137 | 138 | shadow = distanceFromLight <= (shadowCoord.z) ? 0.0 : 1.0 ; 139 | 140 | return shadow; 141 | } 142 | #endif 143 | #endif 144 | 145 | #if !LIGHT_DEPTH_PASS 146 | #if TEXTURE_COLOR 147 | uniform sampler2D textureColor; 148 | #endif 149 | 150 | #if TEXTURE_BUMP||TEXTURE_NORMAL 151 | varying vec3 envEyeVectorOut; 152 | #endif 153 | #if TEXTURE_BUMP 154 | uniform sampler2D textureBump; 155 | #endif 156 | 157 | 158 | #if TEXTURE_ENVSPHERE 159 | uniform sampler2D textureEnvSphere; 160 | uniform float materialEnvironment; 161 | #if TEXTURE_NORMAL 162 | varying vec3 envTexCoordOut; 163 | #else 164 | varying vec2 envTexCoordOut; 165 | #endif 166 | #endif 167 | 168 | #if TEXTURE_REFLECT 169 | uniform sampler2D textureReflect; 170 | #endif 171 | 172 | #if TEXTURE_NORMAL 173 | uniform sampler2D textureNormal; 174 | #endif 175 | 176 | uniform float materialAlpha; 177 | 178 | #if TEXTURE_AMBIENT 179 | uniform sampler2D textureAmbient; 180 | #endif 181 | 182 | #if TEXTURE_SPECULAR 183 | uniform sampler2D textureSpecular; 184 | #endif 185 | 186 | #endif // !LIGHT_DEPTH_PASS 187 | 188 | #if TEXTURE_ALPHA 189 | uniform sampler2D textureAlpha; 190 | #endif 191 | 192 | varying vec4 vertexPositionOut; 193 | 194 | vec2 cubicvr_texCoord() { 195 | #if LIGHT_DEPTH_PASS 196 | return vertexTexCoordOut; 197 | #else 198 | #if POINT_SPRITE 199 | return gl_PointCoord; 200 | #else 201 | #if TEXTURE_BUMP 202 | float height = texture2D(textureBump, vertexTexCoordOut.xy).r; 203 | float v = (height) * 0.05 - 0.04; // * scale and - bias 204 | vec3 eye = normalize(envEyeVectorOut); 205 | return vertexTexCoordOut.xy + (eye.xy * v); 206 | #else 207 | return vertexTexCoordOut; 208 | #endif 209 | #endif 210 | #endif 211 | } 212 | 213 | #if TEXTURE_NORMAL && OES_STANDARD_DERIVATIVES 214 | 215 | #extension GL_OES_standard_derivatives : enable 216 | 217 | // Normal Mapping Without Precomputed Tangents: http://www.thetenthplanet.de/archives/1180 218 | 219 | mat3 cotangent_frame( vec3 N, vec3 p, vec2 uv ) { 220 | // get edge vectors of the pixel triangle 221 | vec3 dp1 = dFdx( p ); 222 | vec3 dp2 = dFdy( p ); 223 | vec2 duv1 = dFdx( uv ); 224 | vec2 duv2 = dFdy( uv ); 225 | 226 | // solve the linear system 227 | vec3 dp2perp = cross( dp2, N ); 228 | vec3 dp1perp = cross( N, dp1 ); 229 | vec3 T = dp2perp * duv1.x + dp1perp * duv2.x; 230 | vec3 B = dp2perp * duv1.y + dp1perp * duv2.y; 231 | 232 | // construct a scale-invariant frame 233 | float invmax = inversesqrt( max( dot(T,T), dot(B,B) ) ); 234 | return mat3( T * invmax, B * invmax, N ); 235 | } 236 | 237 | #define WITH_NORMALMAP_UNSIGNED 1 238 | //#define WITH_NORMALMAP_GREEN_UP 1 239 | //#define WITH_NORMAL_2CHANNEL 1 240 | 241 | vec3 perturb_normal( vec3 N, vec3 V, vec2 texCoord ) { 242 | // assume N, the interpolated vertex normal and 243 | // V, the view vector (vertex to eye) 244 | vec3 map = texture2D( textureNormal, texCoord ).xyz; 245 | #ifdef WITH_NORMALMAP_UNSIGNED 246 | map = map * 255./127. - 128./127.; 247 | #endif 248 | #ifdef WITH_NORMALMAP_2CHANNEL 249 | map.z = sqrt( 1. - dot( map.xy, map.xy ) ); 250 | #endif 251 | #ifdef WITH_NORMALMAP_GREEN_UP 252 | map.y = -map.y; 253 | #endif 254 | mat3 TBN = cotangent_frame( N, -V, texCoord ); 255 | return normalize( TBN * map ); 256 | } 257 | 258 | #endif 259 | 260 | 261 | vec3 cubicvr_normal(vec2 texCoord) { 262 | #if TEXTURE_NORMAL && !LIGHT_DEPTH_PASS 263 | 264 | // use standard derivatives version if available 265 | #if OES_STANDARD_DERIVATIVES 266 | return perturb_normal(vertexNormalOut, vertexPositionOut.xyz, texCoord); 267 | #else 268 | // fake it otherwise, doesn't play well with rotation 269 | vec3 bumpNorm = vec3(texture2D(textureNormal, texCoord)); 270 | 271 | vec3 n = (vec4(normalize(vertexNormalOut),1.0)).xyz; 272 | bumpNorm = (bumpNorm-0.5)*2.0; 273 | bumpNorm.y = -bumpNorm.y; 274 | return normalize((n+bumpNorm)/2.0); 275 | #endif 276 | 277 | #else 278 | return normalize(vertexNormalOut); 279 | #endif 280 | } 281 | 282 | #if FOG_ENABLED 283 | vec4 apply_fog(vec4 color) { 284 | vec4 outColor = color; 285 | 286 | float depth = gl_FragCoord.z / gl_FragCoord.w; 287 | 288 | #if USE_FOG_EXP 289 | const float LOG2 = 1.442695; 290 | float fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 ); 291 | fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 ); 292 | outColor = mix( color, vec4( fogColor, color.w ), fogFactor ); 293 | #endif 294 | 295 | #if USE_FOG_LINEAR 296 | float fogFactor = smoothstep( fogNear, fogFar, depth ); 297 | outColor = mix( color, vec4( fogColor, color.w ), fogFactor ); 298 | #endif 299 | 300 | return outColor; 301 | } 302 | #endif 303 | 304 | vec4 cubicvr_color(vec2 texCoord) { 305 | vec4 color = vec4(0.0,0.0,0.0,0.0); 306 | 307 | #if POINT_SIZE && !POINT_SPRITE && POINT_CIRCLE 308 | if (length(sPos-(gl_FragCoord.xy)) > ptSize/2.0) { 309 | discard; 310 | } 311 | #endif 312 | 313 | #if !LIGHT_DEPTH_PASS 314 | #if TEXTURE_COLOR 315 | #if !(LIGHT_IS_POINT||LIGHT_IS_DIRECTIONAL||LIGHT_IS_SPOT||LIGHT_IS_AREA) 316 | color = texture2D(textureColor, texCoord).rgba; 317 | color.rgb *= materialColor; 318 | //vec4(lightAmbient,1.0)* 319 | #else 320 | color = texture2D(textureColor, texCoord).rgba; 321 | #if !TEXTURE_ALPHA 322 | if (color.a<=0.9) { 323 | discard; 324 | } 325 | #endif 326 | color.rgb *= materialColor; 327 | #endif 328 | #if VERTEX_COLOR 329 | color *= vec4(vertexColorOut,1.0); 330 | #endif 331 | #else 332 | #if VERTEX_COLOR 333 | color = vec4(vertexColorOut,1.0); 334 | #else 335 | color = vec4(materialColor,1.0); 336 | #endif 337 | #endif 338 | 339 | #if TEXTURE_ALPHA 340 | color.a = texture2D(textureAlpha, texCoord).r; 341 | #if FX_DEPTH_ALPHA 342 | if (color.a < 0.9) discard; 343 | #else 344 | #if MATERIAL_ALPHA 345 | color.a *= materialAlpha; 346 | #else 347 | if (color.a < 0.9) discard; 348 | #endif 349 | #endif 350 | #else 351 | #if MATERIAL_ALPHA 352 | color.a = materialAlpha; 353 | #endif 354 | #endif 355 | #endif 356 | 357 | return color; 358 | } 359 | 360 | vec4 cubicvr_lighting(vec4 color_in, vec3 n, vec2 texCoord) { 361 | vec4 color = color_in; 362 | #if !LIGHT_DEPTH_PASS 363 | vec3 accum = lightAmbient; 364 | #if LIGHT_PERPIXEL 365 | #if LIGHT_IS_POINT 366 | 367 | vec3 specTotal = vec3(0.0,0.0,0.0); 368 | 369 | for (int i = 0; i < LIGHT_COUNT; i++) { 370 | 371 | vec3 lightDirection = lightPosition[i]-vertexPositionOut.xyz; 372 | 373 | float dist = length(lightDirection); 374 | 375 | vec3 halfVector = normalize(vec3(0.0,0.0,1.0)+lightDirection); 376 | 377 | float NdotL = max(dot(normalize(lightDirection),n),0.0); 378 | 379 | if (NdotL > 0.0) { 380 | // basic diffuse 381 | float att = clamp(((lightDistance[i]-dist)/lightDistance[i]), 0.0, 1.0)*lightIntensity[i]; 382 | 383 | accum += att * NdotL * lightDiffuse[i] * materialDiffuse; 384 | 385 | float NdotHV = max(dot(n, halfVector),0.0); 386 | 387 | 388 | #if TEXTURE_SPECULAR 389 | vec3 spec2 = lightSpecular[i] * texture2D(textureSpecular, vec2(texCoord.s, texCoord.t)).rgb * pow(NdotHV,materialShininess); 390 | #else 391 | vec3 spec2 = lightSpecular[i] * materialSpecular * pow(NdotHV,materialShininess); 392 | #endif 393 | 394 | specTotal += spec2; 395 | } 396 | 397 | } 398 | 399 | color.rgb *= accum; 400 | color.rgb += specTotal; 401 | #endif 402 | 403 | 404 | 405 | 406 | #if LIGHT_IS_DIRECTIONAL 407 | float NdotL; 408 | float NdotHV = 0.0; 409 | vec3 specTotal = vec3(0.0,0.0,0.0); 410 | vec3 spec2 = vec3(0.0,0.0,0.0); 411 | 412 | vec3 halfVector; 413 | 414 | for (int i = 0; i < LIGHT_COUNT; i++) { 415 | 416 | halfVector = normalize(vec3(0.0,0.0,1.0)-lightDirection[i]); 417 | 418 | NdotL = max(dot(normalize(-lightDirection[i]),n),0.0); 419 | 420 | if (NdotL > 0.0) { 421 | accum += lightIntensity[i] * materialDiffuse * lightDiffuse[i] * NdotL; 422 | 423 | NdotHV = max(dot(n, halfVector),0.0); 424 | 425 | #if TEXTURE_SPECULAR 426 | spec2 = lightSpecular[i] * texture2D(textureSpecular, vec2(texCoord.s, texCoord.t)).rgb * pow(NdotHV,materialShininess); 427 | #else 428 | spec2 = lightSpecular[i] * materialSpecular * pow(NdotHV,materialShininess); 429 | #endif 430 | 431 | specTotal += spec2; 432 | } 433 | } 434 | 435 | color.rgb *= accum; 436 | color.rgb += specTotal; 437 | #endif 438 | 439 | 440 | #if LIGHT_IS_AREA 441 | vec3 specTotal = vec3(0.0,0.0,0.0); 442 | vec3 spec2 = vec3(0.0,0.0,0.0); 443 | float NdotL; 444 | float NdotHV = 0.0; 445 | 446 | vec3 halfVector; 447 | 448 | for (int i = 0; i < LIGHT_COUNT; i++) { 449 | halfVector = normalize(vec3(0.0,0.0,1.0)-lightDirection[i]); 450 | 451 | NdotL = max(dot(normalize(-lightDirection[i]),n),0.0); 452 | 453 | if (NdotL > 0.0) { 454 | 455 | NdotHV = max(dot(n, halfVector),0.0); 456 | 457 | #if LIGHT_SHADOWED 458 | vec4 shadowCoord = lightProjectionOut[i] / lightProjectionOut[i].w; 459 | 460 | shadowCoord.z = DepthRangeA(ConvertDepth3A(shadowCoord.z,lightDepthClip[i].x,lightDepthClip[i].y),lightDepthClip[i].x,lightDepthClip[i].y); 461 | 462 | vec4 shadowSample; 463 | 464 | float shadow = 1.0; 465 | // this seems to get around a shader crash ... 466 | if (shadowCoord.s > 0.000&&shadowCoord.s < 1.000 && shadowCoord.t > 0.000 && shadowCoord.t < 1.000) if (i == 0) { shadow = getShadowVal(lightShadowMap[0],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z);} 467 | #if LIGHT_COUNT>1 468 | if (i == 1) { shadow = getShadowVal(lightShadowMap[1],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 469 | #endif 470 | #if LIGHT_COUNT>2 471 | if (i == 2) { shadow = getShadowVal(lightShadowMap[2],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 472 | #endif 473 | #if LIGHT_COUNT>3 474 | if (i == 3) { shadow = getShadowVal(lightShadowMap[3],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 475 | #endif 476 | #if LIGHT_COUNT>4 477 | if (i == 4) { shadow = getShadowVal(lightShadowMap[4],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 478 | #endif 479 | #if LIGHT_COUNT>5 480 | if (i == 5) { shadow = getShadowVal(lightShadowMap[5],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 481 | #endif 482 | #if LIGHT_COUNT>6 483 | if (i == 6) { shadow = getShadowVal(lightShadowMap[6],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 484 | #endif 485 | #if LIGHT_COUNT>7 486 | if (i == 7) { shadow = getShadowVal(lightShadowMap[7],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 487 | #endif 488 | 489 | accum += shadow * lightIntensity[i] * materialDiffuse * lightDiffuse[i] * NdotL; 490 | #else 491 | accum += lightIntensity[i] * materialDiffuse * lightDiffuse[i] * NdotL; 492 | #endif 493 | 494 | #if TEXTURE_SPECULAR 495 | spec2 = lightSpecular[i] * texture2D(textureSpecular, vec2(texCoord.s, texCoord.t)).rgb * pow(NdotHV,materialShininess); 496 | #else 497 | spec2 = lightSpecular[i] * materialSpecular * pow(NdotHV,materialShininess); 498 | #endif 499 | 500 | #if LIGHT_SHADOWED 501 | spec2 *= shadow; 502 | #endif 503 | 504 | specTotal += spec2; 505 | 506 | #if LIGHT_SHADOWED 507 | // accum = texture2D(lightShadowMap[0], vec2(shadowCoord.s, shadowCoord.t)).rgb; 508 | #endif 509 | 510 | } 511 | } 512 | 513 | color.rgb *= accum; 514 | color.rgb += specTotal; 515 | 516 | #endif 517 | 518 | 519 | #if LIGHT_IS_SPOT 520 | vec3 specTotal = vec3(0.0,0.0,0.0); 521 | vec3 spec2 = vec3(0.0,0.0,0.0); 522 | 523 | vec3 halfVector; 524 | float spotEffect; 525 | float spotDot; 526 | float power; 527 | 528 | for (int i = 0; i < LIGHT_COUNT; i++) { 529 | vec3 l = lightPosition[i]-vertexPositionOut.xyz; 530 | 531 | float dist = length(l); 532 | 533 | float att = clamp(((lightDistance[i]-dist)/lightDistance[i]), 0.0, 1.0)*lightIntensity[i]; 534 | 535 | att = clamp(att,0.0,1.0); 536 | 537 | spotDot = dot(normalize(-l), normalize(lightDirection[i])); 538 | 539 | if ( spotDot < cos((lightCutOffAngle[i]/2.0)*(3.14159/180.0)) ) { 540 | spotEffect = 0.0; 541 | } 542 | else { 543 | spotEffect = pow(spotDot, 1.0); 544 | } 545 | 546 | #if !LIGHT_IS_PROJECTOR 547 | att *= spotEffect; 548 | #endif 549 | 550 | vec3 v = normalize(-vertexPositionOut.xyz); 551 | vec3 h = normalize(l + v); 552 | 553 | float NdotL = max(0.0, dot(n, normalize(l))); 554 | float NdotH = max(0.0, dot(n, h)); 555 | 556 | if (NdotL > 0.0) { 557 | power = pow(NdotH, materialShininess); 558 | } 559 | else { 560 | power = 0.0; 561 | } 562 | 563 | #if LIGHT_SHADOWED 564 | vec4 shadowCoord = lightProjectionOut[i] / lightProjectionOut[i].w; 565 | 566 | shadowCoord.z = DepthRangeA(ConvertDepth3A(shadowCoord.z,lightDepthClip[i].x,lightDepthClip[i].y),lightDepthClip[i].x,lightDepthClip[i].y); 567 | 568 | vec4 shadowSample; 569 | 570 | float shadow = 1.0; 571 | // this seems to get around a shader crash ... 572 | if (shadowCoord.s >= 0.000&&shadowCoord.s <= 1.000 && shadowCoord.t >= 0.000 && shadowCoord.t <= 1.000) if (i == 0) { shadow = getShadowVal(lightShadowMap[0],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z);} 573 | #if LIGHT_COUNT>1 574 | if (i == 1) { shadow = getShadowVal(lightShadowMap[1],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 575 | #endif 576 | #if LIGHT_COUNT>2 577 | if (i == 2) { shadow = getShadowVal(lightShadowMap[2],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 578 | #endif 579 | #if LIGHT_COUNT>3 580 | if (i == 3) { shadow = getShadowVal(lightShadowMap[3],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 581 | #endif 582 | #if LIGHT_COUNT>4 583 | if (i == 4) { shadow = getShadowVal(lightShadowMap[4],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 584 | #endif 585 | #if LIGHT_COUNT>5 586 | if (i == 5) { shadow = getShadowVal(lightShadowMap[5],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 587 | #endif 588 | #if LIGHT_COUNT>6 589 | if (i == 6) { shadow = getShadowVal(lightShadowMap[6],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 590 | #endif 591 | #if LIGHT_COUNT>7 592 | if (i == 7) { shadow = getShadowVal(lightShadowMap[7],shadowCoord,lightProjectionOut[i].w,lightDepthClip[i].z); } 593 | #endif 594 | 595 | att = att * shadow; 596 | #endif 597 | 598 | #if LIGHT_IS_PROJECTOR && LIGHT_SHADOWED 599 | if (shadowCoord.s >= 0.0&&shadowCoord.s <= 1.0 && shadowCoord.t >= 0.0 && shadowCoord.t <= 1.0 && spotDot > cos((90.0)*(3.14159/180.0))) { 600 | vec3 projTex = texture2D(lightProjectionMap[i],shadowCoord.st).rgb; 601 | accum += att * projTex * lightIntensity[i] * materialDiffuse * lightDiffuse[i] * NdotL; 602 | } 603 | #else 604 | accum += att * lightDiffuse[i] * materialDiffuse * NdotL; 605 | #endif 606 | 607 | #if TEXTURE_SPECULAR 608 | spec2 = lightSpecular[i] * texture2D(textureSpecular, vec2(texCoord.s, texCoord.t)).rgb * power; 609 | #else 610 | spec2 = lightSpecular[i] * materialSpecular * power; 611 | #endif 612 | 613 | #if LIGHT_SHADOWED 614 | spec2 *= shadow; 615 | #endif 616 | 617 | specTotal += spec2*spotEffect; 618 | 619 | } 620 | 621 | 622 | color.rgb *= accum; 623 | color.rgb += specTotal; 624 | 625 | #if LIGHT_SHADOWED 626 | // color = texture2D(lightShadowMap[0], vec2(texCoord.s, texCoord.t)).rgba; 627 | 628 | #endif 629 | #endif 630 | #else 631 | // vertex lighting 632 | #if LIGHT_IS_POINT||LIGHT_IS_DIRECTIONAL||LIGHT_IS_SPOT||LIGHT_IS_AREA 633 | color.rgb *= lightColorOut; 634 | color.rgb += lightSpecularOut; 635 | #endif 636 | #endif // LIGHT_PERPIXEL 637 | 638 | #if TEXTURE_AMBIENT 639 | #if LIGHT_IS_POINT||LIGHT_IS_DIRECTIONAL||LIGHT_IS_SPOT||LIGHT_IS_AREA 640 | color.rgb += texture2D(textureAmbient, texCoord).rgb*(vec3(1.0,1.0,1.0)+materialColor*materialAmbient); 641 | #else 642 | color.rgb = color.rgb*texture2D(textureAmbient, texCoord).rgb; 643 | #endif 644 | #else 645 | #if TEXTURE_COLOR 646 | color.rgb += materialAmbient*texture2D(textureColor, texCoord).rgb; 647 | #else 648 | color.rgb += materialColor*materialAmbient; 649 | #endif 650 | #endif 651 | #endif 652 | 653 | #if FOG_ENABLED 654 | return apply_fog(color); 655 | #else 656 | return color; 657 | #endif 658 | } 659 | 660 | vec4 cubicvr_environment(vec4 color_in, vec3 n, vec2 texCoord) { 661 | vec4 color = color_in; 662 | #if !LIGHT_DEPTH_PASS 663 | #if TEXTURE_REFLECT 664 | float environmentAmount = texture2D( textureReflect, texCoord).r; 665 | #endif 666 | 667 | #if TEXTURE_ENVSPHERE 668 | #if TEXTURE_NORMAL 669 | vec3 r = reflect( envTexCoordOut, n ); 670 | float m = 2.0 * sqrt( r.x*r.x + r.y*r.y + (r.z+1.0)*(r.z+1.0) ); 671 | 672 | vec3 coord; 673 | coord.s = r.x/m + 0.5; 674 | coord.t = r.y/m + 0.5; 675 | 676 | #if TEXTURE_REFLECT 677 | color.rgb += materialColor*texture2D( textureEnvSphere, coord.st).rgb * environmentAmount; 678 | #else 679 | color.rgb += materialColor*texture2D( textureEnvSphere, coord.st).rgb * materialEnvironment; 680 | #endif 681 | #else 682 | #if TEXTURE_REFLECT 683 | color.rgb += materialColor*texture2D( textureEnvSphere, envTexCoordOut).rgb * environmentAmount; 684 | #else 685 | color.rgb += materialColor*texture2D( textureEnvSphere, envTexCoordOut).rgb * materialEnvironment; 686 | #endif 687 | #endif 688 | #endif // TEXTURE_ENVSPHERE 689 | 690 | #endif // ! LIGHT_DEPTH_PASS 691 | 692 | #if FX_DEPTH_ALPHA 693 | #if !MATERIAL_ALPHA 694 | float linear_depth = DepthRange( ConvertDepth3(gl_FragCoord.z) ); 695 | 696 | color.a = linear_depth; 697 | #endif 698 | #endif 699 | return color; 700 | } 701 | 702 | 703 | #if LIGHT_DEPTH_PASS 704 | vec4 cubicvr_depthPack(vec2 texCoord) { 705 | #if TEXTURE_ALPHA 706 | float alphaVal = texture2D(textureAlpha, texCoord).r; 707 | if (alphaVal < 0.9) discard; 708 | #endif 709 | 710 | return packFloatToVec4i(DepthRange( ConvertDepth3(gl_FragCoord.z))); 711 | } 712 | #endif 713 | 714 | #define customShader_splice 1 715 | 716 | void main(void) 717 | { 718 | vec2 texCoord = cubicvr_texCoord(); 719 | 720 | #if !LIGHT_DEPTH_PASS 721 | vec4 color = cubicvr_color(texCoord); 722 | vec3 normal = cubicvr_normal(texCoord); 723 | 724 | color = cubicvr_environment(color,normal,texCoord); 725 | color = cubicvr_lighting(color,normal,texCoord); 726 | 727 | gl_FragColor = clamp(color,0.0,1.0); 728 | #else // LIGHT_DEPTH_PASS for shadows, discard to cut 729 | gl_FragColor = cubicvr_depthPack(texCoord); 730 | #endif 731 | } 732 | -------------------------------------------------------------------------------- /src/CubicVR_Core.vs: -------------------------------------------------------------------------------- 1 | attribute vec3 vertexPosition; 2 | attribute vec3 vertexNormal; 3 | attribute vec2 vertexTexCoord; 4 | 5 | #if VERTEX_COLOR 6 | attribute vec3 vertexColor; 7 | varying vec3 vertexColorOut; 8 | #endif 9 | 10 | #if VERTEX_MORPH 11 | attribute vec3 vertexMorphPosition; 12 | attribute vec3 vertexMorphNormal; 13 | uniform float materialMorphWeight; 14 | #endif 15 | 16 | #if POINT_SIZE||POINT_SPRITE 17 | uniform float pointSize; 18 | #endif 19 | 20 | #if POINT_SIZE && !POINT_SPRITE && POINT_CIRCLE 21 | varying float ptSize; 22 | #if POINT_CIRCLE 23 | varying vec2 sPos; 24 | uniform vec3 viewPort; 25 | #endif 26 | #endif 27 | 28 | varying vec2 vertexTexCoordOut; 29 | uniform vec2 materialTexOffset; 30 | 31 | #if !LIGHT_PERPIXEL 32 | #if LIGHT_IS_POINT||LIGHT_IS_DIRECTIONAL||LIGHT_IS_SPOT||LIGHT_IS_AREA 33 | uniform vec3 lightDirection[LIGHT_COUNT]; 34 | uniform vec3 lightPosition[LIGHT_COUNT]; 35 | uniform vec3 lightSpecular[LIGHT_COUNT]; 36 | uniform vec3 lightDiffuse[LIGHT_COUNT]; 37 | uniform float lightIntensity[LIGHT_COUNT]; 38 | uniform float lightDistance[LIGHT_COUNT]; 39 | #if LIGHT_IS_SPOT 40 | uniform float lightCutOffAngle[LIGHT_COUNT]; 41 | #endif 42 | 43 | varying vec3 lightColorOut; 44 | varying vec3 lightSpecularOut; 45 | #endif 46 | 47 | uniform vec3 materialDiffuse; 48 | uniform vec3 materialSpecular; 49 | uniform float materialShininess; 50 | 51 | #endif 52 | 53 | 54 | // #if TEXTURE_COLOR||TEXTURE_BUMP||TEXTURE_NORMAL||TEXTURE_AMBIENT||hasSpecularMap||hasAlphaMap 55 | // #endif 56 | 57 | uniform mat4 matrixModelView; 58 | uniform mat4 matrixProjection; 59 | uniform mat4 matrixObject; 60 | uniform mat3 matrixNormal; 61 | 62 | varying vec3 vertexNormalOut; 63 | varying vec4 vertexPositionOut; 64 | 65 | #if !LIGHT_DEPTH_PASS 66 | 67 | 68 | #if LIGHT_SHADOWED 69 | varying vec4 lightProjectionOut[LIGHT_COUNT]; 70 | uniform mat4 lightShadowMatrix[LIGHT_COUNT]; 71 | #endif 72 | 73 | 74 | #if TEXTURE_ENVSPHERE 75 | #if TEXTURE_NORMAL 76 | varying vec3 envTexCoordOut; 77 | #else 78 | varying vec2 envTexCoordOut; 79 | #endif 80 | #endif 81 | 82 | 83 | 84 | #if TEXTURE_BUMP||TEXTURE_NORMAL 85 | varying vec3 envEyeVectorOut; 86 | #endif 87 | 88 | #endif // !LIGHT_DEPTH_PASS 89 | 90 | 91 | 92 | void cubicvr_normalMap() { 93 | #if !LIGHT_DEPTH_PASS 94 | #if TEXTURE_BUMP||TEXTURE_NORMAL 95 | vec3 tangent; 96 | vec3 binormal; 97 | 98 | vec3 c1 = cross( vertexNormal, vec3(0.0, 0.0, 1.0) ); 99 | vec3 c2 = cross( vertexNormal, vec3(0.0, 1.0, 0.0) ); 100 | 101 | if ( length(c1) > length(c2) ) { 102 | tangent = c1; 103 | } else { 104 | tangent = c2; 105 | } 106 | 107 | tangent = normalize(tangent); 108 | 109 | binormal = cross(vertexNormal, tangent); 110 | binormal = normalize(binormal); 111 | 112 | mat4 uMVOMatrix = matrixModelView * matrixObject; 113 | 114 | mat3 TBNMatrix = mat3( (vec3 (uMVOMatrix * vec4 (tangent, 0.0))), 115 | (vec3 (uMVOMatrix * vec4 (binormal, 0.0))), 116 | (vec3 (uMVOMatrix * vec4 (vertexNormal, 0.0))) 117 | ); 118 | 119 | envEyeVectorOut = vec3(uMVOMatrix * vec4(vertexPosition,1.0)) * TBNMatrix; 120 | #endif 121 | #endif 122 | } 123 | 124 | void cubicvr_environmentMap() { 125 | #if !LIGHT_DEPTH_PASS 126 | #if TEXTURE_ENVSPHERE 127 | #if TEXTURE_NORMAL 128 | envTexCoordOut = normalize( vertexPositionOut.xyz ); 129 | #else 130 | vec3 ws = (matrixModelView * vec4(vertexPosition,1.0)).xyz; 131 | vec3 r = reflect(ws, vertexNormalOut ); 132 | float m = 2.0 * sqrt( r.x*r.x + r.y*r.y + (r.z+1.0)*(r.z+1.0) ); 133 | envTexCoordOut.s = r.x/m + 0.5; 134 | envTexCoordOut.t = r.y/m + 0.5; 135 | #endif 136 | #endif 137 | #if VERTEX_COLOR 138 | vertexColorOut = vertexColor; 139 | #endif 140 | #endif 141 | } 142 | 143 | void cubicvr_shadowMap() { 144 | #if (LIGHT_IS_SPOT||LIGHT_IS_AREA) && LIGHT_SHADOWED 145 | for (int i = 0; i < LIGHT_COUNT; i++) 146 | { 147 | #if LIGHT_SHADOWED 148 | #if VERTEX_MORPH 149 | lightProjectionOut[i] = lightShadowMatrix[i] * (matrixObject * vec4(vertexPosition+(vertexMorphPosition-vertexPosition)*materialMorphWeight, 1.0)); 150 | #else 151 | lightProjectionOut[i] = lightShadowMatrix[i] * (matrixObject * vec4(vertexPosition, 1.0)); 152 | #endif 153 | #endif 154 | } 155 | #endif 156 | } 157 | 158 | void cubicvr_lighting() { 159 | #if !LIGHT_PERPIXEL 160 | #if LIGHT_IS_POINT 161 | 162 | vec3 specTotal = vec3(0.0,0.0,0.0); 163 | vec3 accum = vec3(0.0,0.0,0.0); 164 | 165 | for (int i = 0; i < LIGHT_COUNT; i++) { 166 | 167 | vec3 lightDirection = lightPosition[i]-vertexPositionOut.xyz; 168 | 169 | float dist = length(lightDirection); 170 | 171 | vec3 halfVector = normalize(vec3(0.0,0.0,1.0)+lightDirection); 172 | 173 | float NdotL = max(dot(normalize(lightDirection),vertexNormalOut),0.0); 174 | 175 | if (NdotL > 0.0) { 176 | // basic diffuse 177 | float att = clamp(((lightDistance[i]-dist)/lightDistance[i]), 0.0, 1.0)*lightIntensity[i]; 178 | 179 | accum += att * NdotL * lightDiffuse[i] * materialDiffuse; 180 | 181 | float NdotHV = max(dot(vertexNormalOut, halfVector),0.0); 182 | 183 | vec3 spec2 = lightSpecular[i] * materialSpecular * pow(NdotHV,materialShininess); 184 | 185 | specTotal += spec2; 186 | } 187 | 188 | } 189 | 190 | lightColorOut = accum; 191 | lightSpecularOut = specTotal; 192 | #endif 193 | 194 | #if LIGHT_IS_DIRECTIONAL 195 | float NdotL; 196 | float NdotHV = 0.0; 197 | vec3 specTotal = vec3(0.0,0.0,0.0); 198 | vec3 spec2 = vec3(0.0,0.0,0.0); 199 | vec3 accum = vec3(0.0,0.0,0.0); 200 | 201 | vec3 halfVector; 202 | 203 | for (int i = 0; i < LIGHT_COUNT; i++) { 204 | 205 | halfVector = normalize(vec3(0.0,0.0,1.0)-lightDirection[i]); 206 | 207 | NdotL = max(dot(normalize(-lightDirection[i]),vertexNormalOut),0.0); 208 | 209 | if (NdotL > 0.0) { 210 | accum += lightIntensity[i] * materialDiffuse * lightDiffuse[i] * NdotL; 211 | 212 | NdotHV = max(dot(vertexNormalOut, halfVector),0.0); 213 | 214 | spec2 = lightSpecular[i] * materialSpecular * pow(NdotHV,materialShininess); 215 | 216 | specTotal += spec2; 217 | } 218 | } 219 | 220 | lightColorOut = accum; 221 | lightSpecularOut = specTotal; 222 | #endif 223 | 224 | #if LIGHT_IS_SPOT 225 | vec3 specTotal = vec3(0.0,0.0,0.0); 226 | vec3 spec2 = vec3(0.0,0.0,0.0); 227 | vec3 accum = vec3(0.0,0.0,0.0); 228 | 229 | vec3 halfVector; 230 | float spotEffect; 231 | float spotDot; 232 | float power; 233 | 234 | for (int i = 0; i < LIGHT_COUNT; i++) { 235 | vec3 l = lightPosition[i]-vertexPositionOut.xyz; 236 | 237 | float dist = length(l); 238 | 239 | float att = clamp(((lightDistance[i]-dist)/lightDistance[i]), 0.0, 1.0)*lightIntensity[i]; 240 | 241 | att = clamp(att,0.0,1.0); 242 | 243 | spotDot = dot(normalize(-l), normalize(lightDirection[i])); 244 | 245 | if ( spotDot < cos((lightCutOffAngle[i]/2.0)*(3.14159/180.0)) ) { 246 | spotEffect = 0.0; 247 | } 248 | else { 249 | spotEffect = pow(spotDot, 1.0); 250 | } 251 | 252 | att *= spotEffect; 253 | 254 | vec3 v = normalize(-vertexPositionOut.xyz); 255 | vec3 h = normalize(l + v); 256 | 257 | float NdotL = max(0.0, dot(vertexNormalOut, normalize(l))); 258 | float NdotH = max(0.0, dot(vertexNormalOut, h)); 259 | 260 | if (NdotL > 0.0) { 261 | power = pow(NdotH, materialShininess); 262 | } 263 | else { 264 | power = 0.0; 265 | } 266 | 267 | 268 | accum += att * lightDiffuse[i] * materialDiffuse * NdotL; 269 | 270 | spec2 = lightSpecular[i] * materialSpecular * power; 271 | 272 | specTotal += spec2*spotEffect; 273 | 274 | } 275 | 276 | lightColorOut = accum; 277 | lightSpecularOut = specTotal; 278 | #endif 279 | #endif // !LIGHT_PERPIXEL 280 | cubicvr_normalMap(); 281 | cubicvr_shadowMap(); 282 | cubicvr_environmentMap(); 283 | } 284 | 285 | 286 | 287 | vec2 cubicvr_texCoord() { 288 | return vertexTexCoord + materialTexOffset; 289 | } 290 | 291 | 292 | vec4 cubicvr_transform() { 293 | #if LIGHT_DEPTH_PASS 294 | vertexNormalOut = vec3(0.0,0.0,0.0); 295 | #endif 296 | 297 | #if VERTEX_MORPH 298 | vec4 vPos = matrixObject * vec4(vertexPosition+(vertexMorphPosition-vertexPosition)*materialMorphWeight, 1.0); 299 | #else 300 | vec4 vPos = matrixObject * vec4(vertexPosition, 1.0); 301 | #endif 302 | 303 | vertexPositionOut = matrixModelView * vPos; 304 | 305 | #if POINT_SIZE||POINT_SPRITE 306 | float d = length(vertexPositionOut); 307 | gl_PointSize = pointSize * sqrt( 1.0/(1.0 + d*d) ); 308 | 309 | #if !POINT_SPRITE && POINT_CIRCLE 310 | ptSize = gl_PointSize; 311 | vec4 screenPos = vec4(matrixProjection * vertexPositionOut); 312 | sPos = (screenPos.xy/screenPos.w)*vec2(viewPort.x/2.0,viewPort.y/2.0)+vec2(viewPort.x/2.0+0.5,viewPort.y/2.0+0.5); 313 | #endif 314 | #endif 315 | 316 | return vPos; 317 | } 318 | 319 | vec3 cubicvr_normal() { 320 | #if VERTEX_MORPH 321 | return normalize(matrixObject*vec4(vertexNormal+(vertexMorphNormal-vertexNormal)*materialMorphWeight,0.0)).xyz; 322 | #else 323 | return normalize(matrixObject*vec4(vertexNormal,0.0)).xyz; 324 | #endif 325 | } 326 | 327 | #define customShader_splice 1 328 | 329 | void main(void) 330 | { 331 | vertexTexCoordOut = cubicvr_texCoord(); 332 | gl_Position = matrixProjection * matrixModelView * cubicvr_transform(); 333 | 334 | #if !LIGHT_DEPTH_PASS // not needed if shadowing 335 | 336 | vertexNormalOut = matrixNormal * cubicvr_normal(); 337 | 338 | cubicvr_lighting(); 339 | 340 | #endif // !LIGHT_DEPTH_PASS 341 | } 342 | -------------------------------------------------------------------------------- /src/cl/fracture.cl: -------------------------------------------------------------------------------- 1 | struct Tri { 2 | float4 a, b, c; // x y z _ 3 | }; 4 | 5 | /// Row-major matrix multiplication, assuming `v` is a point (w=1) 6 | inline float4 matmul(float16 m, float4 v) { 7 | v.w = 1.0; 8 | float4 mv = { 9 | dot(m.s0123, v), 10 | dot(m.s4567, v), 11 | dot(m.s89AB, v), 12 | dot(m.sCDEF, v) 13 | }; 14 | return mv; 15 | } 16 | 17 | kernel void transformCopyPerPlane( 18 | /*0*/ uint planecount, 19 | /*1*/ float16 matrix, // The transformation matrix 20 | /*2*/ uint tricount, // Original number of triangles 21 | /*3*/ global int *tricells, // Does not have to be initialized, but should be size planecount*tricount 22 | /*4*/ global struct Tri *tris // Needs to be initialized only for the first tricount elems, but same 23 | ) { 24 | uint i_tri = get_global_id(0); 25 | if (i_tri >= tricount) { 26 | return; 27 | } 28 | 29 | struct Tri t = tris[i_tri]; 30 | t.a = matmul(matrix, t.a); 31 | t.b = matmul(matrix, t.b); 32 | t.c = matmul(matrix, t.c); 33 | 34 | for (int i_plane = 0; i_plane < planecount; i_plane++) { 35 | tricells[i_plane * tricount + i_tri] = i_plane; 36 | tris [i_plane * tricount + i_tri] = t; 37 | } 38 | } 39 | 40 | kernel void applyProximity( 41 | /*0*/ constant uint *prox, // true/false proximate per cell 42 | /*1*/ uint tricount, 43 | /*2*/ global int *tricells // Modified in place 44 | ) { 45 | uint i_tri = get_global_id(0); 46 | if (i_tri >= tricount) { 47 | return; 48 | } 49 | 50 | int c = tricells[i_tri]; 51 | if (c != -1 && !prox[c]) { 52 | tricells[i_tri] = -2; // -1 means delete, -2 doesn't! 53 | } 54 | } 55 | 56 | kernel void getScanInput( 57 | /*0*/ uint count, 58 | /*1*/ constant int *cellnums, // List of cell indices pertaining to another array. If -1, then corresponding index of that array will be removed. 59 | /*2*/ uint outcount, // this needs to be a power of 2. 60 | /*3*/ global int *scaninput // starts as an array of length (minimum power of 2 greater than count). 0 if cellnum[index] is -1, 1 otherwise. 61 | ){ 62 | uint index = get_global_id(0); 63 | if (index >= outcount) { 64 | return; 65 | } 66 | if (index == 0) { 67 | scaninput[index] = 0; 68 | return; 69 | } 70 | uint readindex = index - 1; 71 | if (index < count) { 72 | if (cellnums[readindex] > -1) { 73 | scaninput[index] = 1; 74 | } else { 75 | scaninput[index] = 0; 76 | } 77 | } else { 78 | scaninput[index] = 0; 79 | } 80 | } 81 | 82 | // note that you could potentially do this with a single array that stores both out and in interleaved, and alternates by doing iter%2. 83 | kernel void scanIter( 84 | /*0*/ uint iter, // iteration counter. starts at 1. 85 | /*1*/ uint count, 86 | /*2*/ global int *bufA, // Scan array used as input this iteration. 87 | /*3*/ global int *bufB // Scan array used as output this iteration. 88 | ){ 89 | uint index = get_global_id(0); 90 | if (index >= count) { 91 | return; 92 | } 93 | int pow2 = 1; 94 | for (int i = 0; i < iter; i++) { 95 | pow2 *= 2; 96 | } 97 | if (index >= pow2) { 98 | if (iter % 2 == 0) { 99 | bufB[index] = bufA[index - pow2] + bufA[index]; 100 | } else { 101 | bufA[index] = bufB[index - pow2] + bufB[index]; 102 | 103 | } 104 | } else { 105 | if (iter % 2 == 0) { 106 | bufB[index] = bufA[index]; 107 | } else { 108 | bufA[index] = bufB[index]; 109 | } 110 | } 111 | } 112 | 113 | // may need separate scatters (eg. scatterTri, scatterPoints, ...) 114 | // don't need scanInput's output because you can just check if tricells[index] == -1 115 | kernel void scatterTris( 116 | /*0*/ uint tricount, // size of original array 117 | /*1*/ constant struct Tri *tris, // len is tricount 118 | /*2*/ constant int *tricells, // len is tricount 119 | /*3*/ constant int *scatterout, // len is (minimum power of 2 greater than tricount) 120 | /*4*/ uint trioutcount, // size of new array 121 | /*5*/ global struct Tri *triout, // len is scatterout[tricount] 122 | /*6*/ global int *trioutcells // len is scatterout[tricount] 123 | ){ 124 | uint index = get_global_id(0); 125 | if (index >= tricount) { 126 | return; 127 | } 128 | 129 | if (tricells[index] != -1 && scatterout[index] < trioutcount) { 130 | trioutcells[scatterout[index]] = tricells[index]; 131 | triout[scatterout[index]] = tris[index]; 132 | } 133 | } 134 | 135 | // don't need scanInput's output because you can just check if tricells[index] == -1 136 | kernel void scatterPoints( 137 | /*0*/ uint pointcount, // size of original array 138 | /*1*/ constant float4 *points, // len is pointcount 139 | /*2*/ constant int *pointcells, // len is pointcount 140 | /*3*/ constant int *scatterout, // len is (minimum power of 2 greater than pointcount) 141 | /*4*/ uint pointoutcount, // size of new array 142 | /*5*/ global float4 *pointout, // len is scatterout[pointcount] 143 | /*6*/ global int *pointoutcells // len is scatterout[pointcount] 144 | ){ 145 | uint index = get_global_id(0); 146 | if (index >= pointcount) { 147 | return; 148 | } 149 | 150 | if (pointcells[index] != -1 && scatterout[index] < pointoutcount) { 151 | pointoutcells[scatterout[index]] = pointcells[index]; 152 | pointout[scatterout[index]] = points[index]; 153 | } 154 | } 155 | 156 | kernel void fracture( 157 | // Fracture pattern planes: index these by tricells 158 | /*0*/ uint planecount, 159 | /*1*/ constant float4 *planes, // Nx Ny Nz d 160 | 161 | // Input mesh triangles (initially, one copy per cell) 162 | /*2*/ uint tricount, 163 | /*3*/ constant int *tricells, // len is tricount 164 | /*4*/ constant struct Tri *tris, // len is tricount 165 | 166 | // Output mesh triangles 167 | /*5*/ global int *trioutcells, // len is tricount*2, -1 for nonexistent 168 | /*6*/ global struct Tri *triout, // len is tricount*2 169 | 170 | // Output new vertices for new face 171 | /*7*/ global int *newoutcells, // len is tricount, -1 for nonexistent 172 | /*8*/ global float4 *newout, // len is tricount*2 173 | 174 | /*9*/ float4 fracCenter 175 | ) { 176 | uint index = get_global_id(0); 177 | if (index >= tricount) { 178 | return; 179 | } 180 | 181 | int cell = tricells[index]; 182 | float4 _pla = planes[cell]; 183 | if (_pla.x == 0 && _pla.y == 0 && _pla.z == 0) { 184 | // this cell doesn't have a plane on this iteration; do nothing 185 | trioutcells[2 * index] = cell; 186 | triout[2 * index] = tris[index]; 187 | trioutcells[2 * index + 1] = -1; 188 | newoutcells[index] = -1; 189 | return; 190 | } 191 | float4 pN = {_pla.xyz, 0}; 192 | // move the plane into local coordinate system. 193 | float pd = _pla.w + dot(pN, fracCenter); 194 | float4 pP = {0, 0, -pd / pN.z, 0}; // Arbitrarily calculate a point on the plane (z-axis intersection) 195 | 196 | struct Tri tri = tris[index]; 197 | 198 | // TODO: perform plane-triangle clip 199 | bool cull1, cull2, cull3, tempb; 200 | bool winding = true; // keeps track of whether or not the winding is still consistent. 201 | cull1 = dot(pN, tri.a - pP) < 0; 202 | cull2 = dot(pN, tri.b - pP) < 0; 203 | cull3 = dot(pN, tri.c - pP) < 0; 204 | 205 | float4 p1 = tri.a; 206 | float4 p2 = tri.b; 207 | float4 p3 = tri.c; 208 | // sort the points from culled to not culled. 209 | if (!cull1) { // if cull1 is false, swap 1 and 3 (order 321) 210 | // is this faster than putting if-else? if (cull3){...} else if (cull2){...} 211 | cull1 = cull3; 212 | cull3 = false; 213 | p1 = tri.c; 214 | p2 = tri.b; 215 | p3 = tri.a; 216 | 217 | winding = false; 218 | 219 | if (!cull1) { // if it's still false, swap 1 and 2 (final order 231) 220 | cull1 = cull2; 221 | cull2 = false; 222 | p1 = tri.b; 223 | p2 = tri.c; 224 | 225 | winding = true; 226 | } 227 | } else if (!cull2) { 228 | cull2 = cull3; 229 | cull3 = false; 230 | 231 | p1 = tri.a; 232 | p2 = tri.c; 233 | p3 = tri.b; 234 | 235 | winding = false; 236 | } 237 | 238 | // note that it's configured to output only the original triangle by default. 239 | struct Tri newTri1, newTri2; 240 | newTri1 = tri; // current triangle. 241 | int cell1 = cell; // cell of the current face. 242 | int cell2 = -1; // cell of the new face. 243 | int cellP = -1; // cell of the new points (for newoutcells). 244 | float4 newP1, newP2; // new points. 245 | 246 | if (cull3) { // if all 3 points are culled, do nothing. Output is -1 247 | // set cell1 to -1. 248 | cell1 = -1; 249 | } else if (!cull1) { // if all 3 points are not culled, add to output normally. 250 | // do nothing. 251 | } else if (!cull2) { // XOR: if only one point is culled (p1), needs new face, add both to output 252 | // calculate new edge p1-p2 253 | float4 v = normalize(p1 - p2); 254 | newP1 = p2 + v * -(dot(p2, pN) + pd) / dot(v, pN); 255 | 256 | // calculate new edge p1-p3 257 | v = normalize(p1 - p3); 258 | newP2 = p3 + v * -(dot(p3, pN) + pd) / dot(v, pN); 259 | 260 | newTri1.a = newTri2.a = p2; 261 | if (winding) { 262 | newTri1.b = newP2; 263 | newTri1.c = newP1; 264 | newTri2.b = p3; 265 | newTri2.c = newP2; 266 | } else { 267 | newTri1.b = newP1; 268 | newTri1.c = newP2; 269 | newTri2.b = newP2; 270 | newTri2.c = p3; 271 | } 272 | 273 | // Both new faces and new points 274 | cell2 = cellP = cell; 275 | } else { // two points culled (p1, p2), modify current face and add to output 276 | // calculate new edge p2 - p3 277 | float4 v = normalize(p2 - p3); 278 | newP1 = p3 + v * -(dot(p3, pN) + pd) / dot(v, pN); 279 | 280 | // calculate new edge p1-p3 281 | v = normalize(p1 - p3); 282 | newP2 = p3 + v * -(dot(p3, pN) + pd) / dot(v, pN); 283 | 284 | // set new points 285 | newTri1.a = newP1; 286 | if (winding) { 287 | newTri1.b = p3; 288 | newTri1.c = newP2; 289 | } else { 290 | newTri1.b = newP2; 291 | newTri1.c = p3; 292 | } 293 | 294 | // just new points. 295 | cellP = cell; 296 | } 297 | 298 | // output triangles. 299 | trioutcells[2 * index] = cell1; 300 | triout[2 * index] = newTri1; 301 | trioutcells[2 * index + 1] = cell2; 302 | triout[2 * index + 1] = newTri2; 303 | 304 | // output new points (for later triangulation). 305 | newoutcells[index] = cellP; 306 | if (winding) { 307 | newout[2 * index] = newP1; 308 | newout[2 * index + 1] = newP2; 309 | } else { 310 | newout[2 * index] = newP2; 311 | newout[2 * index + 1] = newP1; 312 | } 313 | 314 | /* 315 | // the following should do nothing. 316 | trioutcells[2 * index] = cell; 317 | triout[2 * index] = tris[index]; 318 | trioutcells[2 * index + 1] = -1; 319 | newoutcells[index] = -1; 320 | */ 321 | } 322 | -------------------------------------------------------------------------------- /src/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CubicVR.js: AMMO physics adapter test 6 | 7 | 8 | 9 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 50 | 51 | 52 | 58 |
59 | Faces: 0
60 | Vertices: 0
61 | Meshes: 0 62 |
63 | 64 | 65 | -------------------------------------------------------------------------------- /src/index_old.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CubicVR.js: AMMO physics adapter test 6 | 7 | 8 | 9 | 10 | 339 | 340 | 341 | 342 | -------------------------------------------------------------------------------- /src/js/fracturecl.js: -------------------------------------------------------------------------------- 1 | function loadKernel(id) { 2 | var kernelElement = document.getElementById(id); 3 | var kernelSource = kernelElement.text; 4 | if (kernelElement.src != "") { 5 | var mHttpReq = new XMLHttpRequest(); 6 | mHttpReq.open("GET", kernelElement.src, false); 7 | mHttpReq.send(null); 8 | kernelSource = mHttpReq.responseText; 9 | } 10 | return kernelSource; 11 | } 12 | 13 | function index3(array, index) { 14 | return [array[4 * index + 0], 15 | array[4 * index + 1], 16 | array[4 * index + 2]]; 17 | } 18 | 19 | function clInit() { 20 | var ctx = webcl.createContext(/*WebCL.DEVICE_TYPE_GPU*/); 21 | var kernelSrc = loadKernel("fracturecl"); 22 | var program = ctx.createProgram(kernelSrc); 23 | var device = ctx.getInfo(WebCL.CONTEXT_DEVICES)[0]; 24 | console.log(device.getInfo(WebCL.DEVICE_NAME)); 25 | 26 | try { 27 | program.build([device], ""); 28 | } catch (e) { 29 | alert("Failed to build WebCL program. Error " 30 | + program.getBuildInfo(device, WebCL.PROGRAM_BUILD_STATUS) 31 | + ": " 32 | + program.getBuildInfo(device, WebCL.PROGRAM_BUILD_LOG)); 33 | throw e; 34 | } 35 | 36 | var cl = {}; 37 | cl.ctx = ctx; 38 | cl.kernel = program.createKernel("fracture"); 39 | cl.copykernel = program.createKernel("transformCopyPerPlane"); 40 | cl.proxkernel = program.createKernel("applyProximity"); 41 | cl.queue = ctx.createCommandQueue(device); 42 | return cl; 43 | } 44 | 45 | function clSetCells(cl, cells, influence) { 46 | var cellProximate = []; 47 | var planesPerCell = []; 48 | for (var i = 0; i < cells.length; i++) { 49 | var cell = cells[i].mesh; 50 | var center = cells[i].position; //NOTE: This assumes that the position of each cell is inside of it! 51 | 52 | var prox = false; 53 | for (var j = 0; j < cell.points.length; j++) { 54 | if (length3(sub3(cell.points[j], center)) < influence) { 55 | prox = true; 56 | break; 57 | } 58 | } 59 | cellProximate[i] = prox; 60 | 61 | var cellPlanes = cellToPlanes(cell, center, center); 62 | planesPerCell[i] = cellPlanes; 63 | } 64 | cl.proximate = cellProximate; // for debug view 65 | cellProximate = new Uint32Array(cellProximate); 66 | 67 | var cellsPerIndex = []; 68 | for (var i = 0; true; i++) { 69 | var planescurr = []; 70 | var nonempty = false; 71 | for (var j = 0; j < planesPerCell.length; j++) { 72 | var ap = planesPerCell[j]; 73 | if (i < ap.length) { 74 | planescurr.push(ap[i]); 75 | nonempty = true; 76 | } else { 77 | planescurr.push({normal: [0, 0, 0], d: 0}); 78 | } 79 | } 80 | if (nonempty) { 81 | cellsPerIndex.push(planescurr); 82 | } else { 83 | break; 84 | } 85 | } 86 | 87 | var cpiBuffers = []; 88 | for (var i = 0; i < cellsPerIndex.length; i++) { 89 | var cpi = cellsPerIndex[i]; 90 | var arr = new Float32Array(cpi.length * 4); 91 | for (var j = 0; j < cpi.length; j++) { 92 | var cj = cpi[j]; 93 | arr[4 * j + 0] = cj.normal[0]; 94 | arr[4 * j + 1] = cj.normal[1]; 95 | arr[4 * j + 2] = cj.normal[2]; 96 | arr[4 * j + 3] = cj.d; 97 | } 98 | 99 | var buf = cl.ctx.createBuffer(WebCL.MEM_READ_ONLY, arr.byteLength); 100 | cl.queue.enqueueWriteBuffer(buf, false, 0, arr.byteLength, arr); 101 | cpiBuffers.push(buf); 102 | } 103 | 104 | cl.cellCount = cells.length; 105 | cl.cellBuffers = cpiBuffers; 106 | 107 | var buf = cl.ctx.createBuffer(WebCL.MEM_READ_ONLY, cellProximate.byteLength); 108 | cl.queue.enqueueWriteBuffer(buf, false, 0, cellProximate.byteLength, cellProximate); 109 | cl.cellProxBuf = buf; 110 | cl.proxkernel.setArg(0, cl.cellProxBuf); 111 | } 112 | 113 | function floatNcompact(N, index, val) { 114 | var indices = []; 115 | var values = []; 116 | for (var i = 0; i < index.length; i++) { 117 | if (index[i] != -1) { 118 | indices.push(index[i]); 119 | for (var n = 0; n < N; n++) { 120 | values.push(val[i * N + n]); 121 | } 122 | } 123 | } 124 | return {indices: indices, values: values}; 125 | } 126 | 127 | function pushfloat4(arr, val) { 128 | arr.push(val[0]); 129 | arr.push(val[1]); 130 | arr.push(val[2]); 131 | arr.push(0); 132 | } 133 | 134 | function makeFace(indices, points) { 135 | var lastidx = -1; 136 | var faces = []; 137 | for (var i = 0; i < indices.length; i++) { 138 | var idx = indices[i]; 139 | var f = faces[idx]; 140 | if (!f) { 141 | f = faces[idx] = []; 142 | } 143 | 144 | // save the current two points into the correct face 145 | var p1 = [points[i * 8 + 0], 146 | points[i * 8 + 1], 147 | points[i * 8 + 2]]; 148 | var p2 = [points[i * 8 + 4], 149 | points[i * 8 + 5], 150 | points[i * 8 + 6]]; 151 | f.push([p1, p2]); 152 | } 153 | 154 | var idxout = []; 155 | var values = []; 156 | for (var iface = 0; iface < faces.length; iface++) { 157 | var f = faces[iface]; 158 | if (!f) { 159 | continue; 160 | } 161 | 162 | var centr = [0, 0, 0]; 163 | for (var j = 0; j < f.length; j++) { 164 | centr = add3(centr, add3(f[j][0], f[j][1])); 165 | } 166 | centr = mult3c(centr, 0.5 / f.length); 167 | 168 | // Create a tri from the centroid and the two points on each edge 169 | for (var i = 0; i < f.length; i++) { 170 | idxout.push(iface); 171 | pushfloat4(values, centr); 172 | pushfloat4(values, f[i][0]); 173 | pushfloat4(values, f[i][1]); 174 | } 175 | } 176 | 177 | return {indices: idxout, values: values}; 178 | } 179 | 180 | var time_setup_input; 181 | var time_setup_rest; 182 | 183 | function clSetupArgs(cl, iteration, tricount) { 184 | if (iteration > 0) { 185 | var t0 = performance.now(); 186 | cl.buftricells = cl.ctx.createBuffer(WebCL.MEM_READ_ONLY, cl.arrtricells.byteLength); 187 | cl.buftris = cl.ctx.createBuffer(WebCL.MEM_READ_ONLY, cl.arrtris.byteLength); 188 | cl.queue.enqueueWriteBuffer(cl.buftris , false, 0, cl.arrtris .byteLength, cl.arrtris); 189 | cl.queue.enqueueWriteBuffer(cl.buftricells, false, 0, cl.arrtricells.byteLength, cl.arrtricells); 190 | cl.queue.finish(); 191 | time_setup_input += performance.now() - t0; 192 | } 193 | 194 | var t0 = performance.now(); 195 | 196 | cl.buftrioutcells = cl.ctx.createBuffer(WebCL.MEM_READ_WRITE, tricount * 2 * 4); 197 | cl.buftriout = cl.ctx.createBuffer(WebCL.MEM_WRITE_ONLY, tricount * 2 * 12 * 4); 198 | cl.bufnewoutcells = cl.ctx.createBuffer(WebCL.MEM_WRITE_ONLY, tricount * 4); 199 | cl.bufnewout = cl.ctx.createBuffer(WebCL.MEM_WRITE_ONLY, tricount * 2 * 4 * 4); 200 | cl.queue.finish(); 201 | 202 | cl.kernel.setArg(0, new Uint32Array([cl.cellCount])); 203 | cl.kernel.setArg(1, cl.cellBuffers[iteration]); 204 | 205 | cl.kernel.setArg(2, new Uint32Array([tricount])); 206 | cl.kernel.setArg(3, cl.buftricells); 207 | cl.kernel.setArg(4, cl.buftris); 208 | 209 | cl.kernel.setArg(5, cl.buftrioutcells); 210 | cl.kernel.setArg(6, cl.buftriout); 211 | 212 | cl.kernel.setArg(7, cl.bufnewoutcells); 213 | cl.kernel.setArg(8, cl.bufnewout); 214 | 215 | cl.kernel.setArg(9, cl.fractureCenter); 216 | 217 | cl.queue.finish(); 218 | time_setup_rest += performance.now() - t0; 219 | } 220 | 221 | var time_readbuffers; 222 | var time_compact_tris; 223 | var time_compact_news; 224 | var time_makeface; 225 | 226 | function clOutputToInput(cl, oldtricount) { 227 | var t0 = performance.now(); 228 | 229 | cl.buftris.release(); 230 | 231 | var arrtrioutcells = new Int32Array(oldtricount * 2); 232 | var arrtriout = new Float32Array(oldtricount * 2 * 12); 233 | var arrnewoutcells = new Int32Array(oldtricount); 234 | var arrnewout = new Float32Array(oldtricount * 2 * 4) 235 | cl.queue.enqueueReadBuffer(cl.buftrioutcells, false, 0, arrtrioutcells.byteLength, arrtrioutcells); 236 | cl.queue.enqueueReadBuffer(cl.buftriout , false, 0, arrtriout .byteLength, arrtriout ); 237 | cl.queue.enqueueReadBuffer(cl.bufnewoutcells, false, 0, arrnewoutcells.byteLength, arrnewoutcells); 238 | cl.queue.enqueueReadBuffer(cl.bufnewout , false, 0, arrnewout .byteLength, arrnewout ); 239 | 240 | cl.buftrioutcells.release(); 241 | cl.buftriout .release(); 242 | cl.bufnewoutcells.release(); 243 | cl.bufnewout .release(); 244 | 245 | cl.queue.finish(); 246 | 247 | var t1 = performance.now(); 248 | 249 | var tmp; 250 | tmp = floatNcompact(12, arrtrioutcells, arrtriout); 251 | var tricells = tmp.indices; 252 | var tris = tmp.values; 253 | 254 | var t2 = performance.now(); 255 | 256 | tmp = floatNcompact( 8, arrnewoutcells, arrnewout); 257 | var newcells = tmp.indices; 258 | var news = tmp.values; 259 | 260 | var t3 = performance.now(); 261 | 262 | tmp = makeFace(newcells, news); 263 | tricells = tricells.concat(tmp.indices); 264 | tris = tris .concat(tmp.values); 265 | 266 | cl.arrtricells = new Int32Array(tricells); 267 | cl.arrtris = new Float32Array(tris); 268 | 269 | var t4 = performance.now(); 270 | 271 | time_readbuffers += t1 - t0; 272 | time_compact_tris += t2 - t1; 273 | time_compact_news += t3 - t2; 274 | time_makeface += t4 - t3; 275 | } 276 | 277 | function clVertfaceToTris(cl, vertices, faces) { 278 | // create initial array of mesh data 279 | var tricount = faces.length; 280 | cl.arrtris = new Float32Array(tricount * 3 * 4); 281 | for (var t = 0; t < tricount; t++) { 282 | for (var v = 0; v < 3; v++) { 283 | var tv = (t * 3 + v) * 4; 284 | for (var a = 0; a < 3; a++) { 285 | cl.arrtris[tv + a] = vertices[faces[t].points[v]][a]; 286 | } 287 | cl.arrtris[tv + 3] = 0; 288 | } 289 | } 290 | } 291 | 292 | function clTransformCopyPerPlane(cl, vertices, faces, transform) { 293 | var tricount = faces.length; 294 | 295 | // Create the array of triangle data for one copy of the mesh 296 | clVertfaceToTris(cl, vertices, faces); 297 | 298 | // Allocate memory for one copy per cell of the mesh 299 | cl.buftricells = cl.ctx.createBuffer(WebCL.MEM_READ_WRITE, cl.cellCount * tricount * 4); 300 | cl.buftris = cl.ctx.createBuffer(WebCL.MEM_READ_WRITE, cl.cellCount * tricount * 12 * 4); 301 | cl.queue.enqueueWriteBuffer(cl.buftris, false, 0, cl.arrtris.byteLength, cl.arrtris); 302 | cl.copykernel.setArg(0, new Uint32Array([cl.cellCount])); 303 | cl.copykernel.setArg(1, new Float32Array(transform)); 304 | cl.copykernel.setArg(2, new Uint32Array([tricount])); 305 | cl.copykernel.setArg(3, cl.buftricells); 306 | cl.copykernel.setArg(4, cl.buftris); 307 | 308 | var localsize = 1; 309 | var localWS = [localsize]; 310 | var globalWS = [Math.ceil(tricount / localsize) * localsize]; 311 | cl.queue.enqueueNDRangeKernel(cl.copykernel, globalWS.length, null, globalWS, localWS); 312 | 313 | cl.queue.finish(); 314 | 315 | return tricount * cl.cellCount; 316 | } 317 | 318 | function clFracture(cl, vertices, faces, rotation, pImpact) { 319 | var tInit = performance.now(); 320 | var t0; 321 | time_readbuffers = 0; 322 | time_compact_tris = 0; 323 | time_compact_news = 0; 324 | time_makeface = 0; 325 | time_setup_input = 0; 326 | time_setup_rest = 0; 327 | 328 | var vertcount = vertices.length; 329 | var tricount = faces.length; 330 | 331 | pImpact.push(0); 332 | cl.fractureCenter = new Float32Array(mult3c(pImpact, -1)); 333 | 334 | //console.log(typeof pImpact[0]); 335 | //console.log(typeof rotation[0]); 336 | 337 | var transform = [rotation[0], rotation[1], rotation[2], 0, 338 | rotation[3], rotation[4], rotation[5], 0, 339 | rotation[6], rotation[7], rotation[8], 0, 340 | 0, 0, 0, 1]; 341 | 342 | t0 = performance.now(); 343 | tricount = clTransformCopyPerPlane(cl, vertices, faces, transform); 344 | var time_transformcopy = performance.now() - t0; 345 | 346 | var time_setupargs = 0; 347 | var time_kernel = 0; 348 | var time_outputtoinput = 0; 349 | 350 | t0 = performance.now(); 351 | var localsize = 1; 352 | for (var i = 0; i < cl.cellBuffers.length; i++) { 353 | var t1 = performance.now(); 354 | 355 | clSetupArgs(cl, i, tricount); 356 | 357 | var t2 = performance.now(); 358 | 359 | var localWS = [localsize]; 360 | var globalWS = [Math.ceil(tricount / localsize) * localsize]; 361 | cl.queue.enqueueNDRangeKernel(cl.kernel, globalWS.length, null, globalWS, localWS); 362 | cl.queue.finish(); 363 | 364 | var t3 = performance.now(); 365 | 366 | if (i == cl.cellBuffers.length - 1) { 367 | // on the last iteration, before copying to cpu, merge faraway cells 368 | var localWS = [localsize]; 369 | var globalWS = [Math.ceil(tricount * 2 / localsize) * localsize]; 370 | cl.proxkernel.setArg(1, new Uint32Array([tricount * 2])); 371 | cl.proxkernel.setArg(2, cl.buftrioutcells); 372 | cl.queue.enqueueNDRangeKernel(cl.proxkernel, globalWS.length, null, globalWS, localWS); 373 | cl.queue.finish(); 374 | var time_proximity = performance.now() - t3; 375 | } 376 | 377 | var t4 = performance.now(); 378 | clOutputToInput(cl, tricount); 379 | tricount = cl.arrtricells.length; 380 | 381 | var t5 = performance.now(); 382 | time_setupargs += t2 - t1; 383 | time_kernel += t3 - t2; 384 | time_outputtoinput += t5 - t4; 385 | } 386 | var time_total_iterations = performance.now() - t0; 387 | 388 | t0 = performance.now(); 389 | var cellfaces = []; 390 | for (var i = 0; i < cl.arrtricells.length; i++) { 391 | var idx = cl.arrtricells[i] + 2; // so that -2 becomes a valid cell 392 | var c = cellfaces[idx]; 393 | if (!c) { 394 | c = cellfaces[idx] = {points: [], faces: [], 395 | min: [10000, 10000, 10000], max: [-10000, -10000, -10000]}; 396 | } 397 | 398 | for (var v = 0; v < 3; v++) { 399 | var off = i * 12 + v * 4; 400 | var p = [cl.arrtris[off + 0], 401 | cl.arrtris[off + 1], 402 | cl.arrtris[off + 2]] 403 | c.points.push(p); 404 | c.min = compwise(Math.min, c.min, p); 405 | c.max = compwise(Math.max, c.max, p); 406 | } 407 | var ci = c.faces.length * 3; 408 | c.faces.push([ci, ci + 1, ci + 2]); 409 | } 410 | var time_collect = performance.now() - t0; 411 | 412 | t0 = performance.now(); 413 | for (var i = 0; i < cellfaces.length; i++) { 414 | var c = cellfaces[i]; 415 | if (!c) { 416 | continue; 417 | } 418 | 419 | c.position = mult3c(add3(c.min, c.max), 0.5); 420 | c.size = sub3(c.max, c.min); 421 | for (var j = 0; j < c.points.length; j++) { 422 | c.points[j] = sub3(c.points[j], c.position); 423 | } 424 | } 425 | var time_recenter = performance.now() - t0; 426 | 427 | var time_clFracture = performance.now() - tInit; 428 | 429 | console.log("v time_transformcopy: " + time_transformcopy); 430 | console.log(" v time_setup_input: " + time_setup_input); 431 | console.log(" v time_setup_rest: " + time_setup_rest); 432 | console.log(" v time_setupargs: " + time_setupargs); 433 | console.log(" v time_kernel: " + time_kernel); 434 | console.log(" v time_readbuffers: " + time_readbuffers); 435 | console.log(" v time_compact_tris: " + time_compact_tris); 436 | console.log(" v time_compact_news: " + time_compact_news); 437 | console.log(" v time_makeface: " + time_makeface); 438 | console.log(" v time_outputtoinput: " + time_outputtoinput); 439 | console.log(" v time_proximity: " + time_proximity); 440 | console.log("v time_total_iterations: " + time_total_iterations); 441 | console.log("v time_collect: " + time_collect); 442 | console.log("v time_recenter: " + time_recenter); 443 | console.log("time_clFracture: " + time_clFracture); 444 | 445 | return cellfaces; 446 | } 447 | -------------------------------------------------------------------------------- /src/js/ourmath.js: -------------------------------------------------------------------------------- 1 | function cross3(a, b) { 2 | return [a[1]*b[2] - a[2]*b[1], a[2]*b[0] - a[0]*b[2], a[0]*b[1] - a[1]*b[0]]; 3 | } 4 | 5 | function dot3(a, b) { 6 | return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]; 7 | } 8 | 9 | function add3(a, b) { 10 | return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; 11 | } 12 | 13 | function sub3(a, b) { 14 | return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; 15 | } 16 | 17 | function mult3c(a, c) { 18 | return [a[0]*c, a[1]*c, a[2]*c]; 19 | } 20 | 21 | function length3(a) { 22 | return Math.sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]); 23 | } 24 | 25 | function compwise(f, a, b) { 26 | return [f(a[0], b[0]), f(a[1], b[1]), f(a[2], b[2])]; 27 | } 28 | 29 | function normalize3(a) { 30 | var length = length3(a); 31 | return [a[0]/length, a[1]/length, a[2]/length]; 32 | } 33 | 34 | function nearlyEqual3(a, b) { 35 | var EPSILON = 0.0001; 36 | return Math.abs(dot3(a, b) - 1) < EPSILON; 37 | } 38 | 39 | function containsNormal(a, norm) { 40 | var i = a.length; 41 | while(--i >= 0) { 42 | if (nearlyEqual3(a[i].normal, norm)) { 43 | return true; 44 | } 45 | } 46 | return false; 47 | } 48 | 49 | function toRotationMatrix(a) { 50 | var m = mat3Id(); 51 | var m1 = mat3Id(); 52 | var DEG_TO_RAD = 3.14159265359/180.0; 53 | var sAng, cAng; 54 | 55 | if (a[2]) { 56 | m1 = mat3Id(); 57 | sAng = Math.sin(-a[2] * DEG_TO_RAD); 58 | cAng = Math.cos(-a[2] * DEG_TO_RAD); 59 | m1[0] = cAng; m1[1] = sAng; 60 | m1[3] = -sAng; m1[4] = cAng; 61 | 62 | m = mat3mult(m, m1); 63 | } 64 | if (a[1]) { 65 | m1 = mat3Id(); 66 | sAng = Math.sin(-a[1] * DEG_TO_RAD); 67 | cAng = Math.cos(-a[1] * DEG_TO_RAD); 68 | m1[0] = cAng; m1[2] = -sAng; 69 | m1[6] = sAng; m1[8] = cAng; 70 | 71 | m = mat3mult(m, m1); 72 | } 73 | if (a[0]) { 74 | m1 = mat3Id(); 75 | sAng = Math.sin(-a[0] * DEG_TO_RAD); 76 | cAng = Math.cos(-a[0] * DEG_TO_RAD); 77 | m1[4] = cAng; m1[5] = sAng; 78 | m1[7] = -sAng; m1[8] = cAng; 79 | 80 | m = mat3mult(m, m1); 81 | } 82 | return m; 83 | } 84 | 85 | function mat3Id() { 86 | var mat = [1, 0, 0, 87 | 0, 1, 0, 88 | 0, 0, 1]; 89 | return mat; 90 | } 91 | 92 | function mat3mult(a, b) { 93 | var mat = []; 94 | mat.push(a[0] * b[0] + a[1] * b[3] + a[2] * b[6]); 95 | mat.push(a[0] * b[1] + a[1] * b[4] + a[2] * b[7]); 96 | mat.push(a[0] * b[2] + a[1] * b[5] + a[2] * b[8]); 97 | mat.push(a[3] * b[0] + a[4] * b[3] + a[5] * b[6]); 98 | mat.push(a[3] * b[1] + a[4] * b[4] + a[5] * b[7]); 99 | mat.push(a[3] * b[2] + a[4] * b[5] + a[5] * b[8]); 100 | mat.push(a[6] * b[0] + a[7] * b[3] + a[8] * b[6]); 101 | mat.push(a[6] * b[1] + a[7] * b[4] + a[8] * b[7]); 102 | mat.push(a[6] * b[2] + a[7] * b[5] + a[8] * b[8]); 103 | 104 | return mat; 105 | } 106 | 107 | function mat3vec3mult(m, v) { 108 | var outVec = []; 109 | outVec.push(m[0] * v[0] + m[1] * v[1] + m[2] * v[2]); 110 | outVec.push(m[3] * v[0] + m[4] * v[1] + m[5] * v[2]); 111 | outVec.push(m[6] * v[0] + m[7] * v[1] + m[8] * v[2]); 112 | 113 | return outVec; 114 | } 115 | 116 | function contains3c(a, c) { 117 | return a[0] == c || a[1] == c || a[2] == c; 118 | } 119 | 120 | function equals2i(a, b) { 121 | return (a[0] == b[0] && a[1] == b[1]) || (a[1] == b[0] && a[0] == b[1]); 122 | } 123 | -------------------------------------------------------------------------------- /src/lib/stats.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @author mrdoob / http://mrdoob.com/ 3 | */ 4 | 5 | var Stats = function () { 6 | 7 | var startTime = Date.now(), prevTime = startTime; 8 | var ms = 0, msMin = Infinity, msMax = 0; 9 | var fps = 0, fpsMin = Infinity, fpsMax = 0; 10 | var frames = 0, mode = 0; 11 | 12 | var container = document.createElement( 'div' ); 13 | container.id = 'stats'; 14 | container.addEventListener( 'mousedown', function ( event ) { event.preventDefault(); setMode( ++ mode % 2 ) }, false ); 15 | container.style.cssText = 'width:80px;opacity:0.9;cursor:pointer'; 16 | 17 | var fpsDiv = document.createElement( 'div' ); 18 | fpsDiv.id = 'fps'; 19 | fpsDiv.style.cssText = 'padding:0 0 3px 3px;text-align:left;background-color:#002'; 20 | container.appendChild( fpsDiv ); 21 | 22 | var fpsText = document.createElement( 'div' ); 23 | fpsText.id = 'fpsText'; 24 | fpsText.style.cssText = 'color:#0ff;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px'; 25 | fpsText.innerHTML = 'FPS'; 26 | fpsDiv.appendChild( fpsText ); 27 | 28 | var fpsGraph = document.createElement( 'div' ); 29 | fpsGraph.id = 'fpsGraph'; 30 | fpsGraph.style.cssText = 'position:relative;width:74px;height:30px;background-color:#0ff'; 31 | fpsDiv.appendChild( fpsGraph ); 32 | 33 | while ( fpsGraph.children.length < 74 ) { 34 | 35 | var bar = document.createElement( 'span' ); 36 | bar.style.cssText = 'width:1px;height:30px;float:left;background-color:#113'; 37 | fpsGraph.appendChild( bar ); 38 | 39 | } 40 | 41 | var msDiv = document.createElement( 'div' ); 42 | msDiv.id = 'ms'; 43 | msDiv.style.cssText = 'padding:0 0 3px 3px;text-align:left;background-color:#020;display:none'; 44 | container.appendChild( msDiv ); 45 | 46 | var msText = document.createElement( 'div' ); 47 | msText.id = 'msText'; 48 | msText.style.cssText = 'color:#0f0;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px'; 49 | msText.innerHTML = 'MS'; 50 | msDiv.appendChild( msText ); 51 | 52 | var msGraph = document.createElement( 'div' ); 53 | msGraph.id = 'msGraph'; 54 | msGraph.style.cssText = 'position:relative;width:74px;height:30px;background-color:#0f0'; 55 | msDiv.appendChild( msGraph ); 56 | 57 | while ( msGraph.children.length < 74 ) { 58 | 59 | var bar = document.createElement( 'span' ); 60 | bar.style.cssText = 'width:1px;height:30px;float:left;background-color:#131'; 61 | msGraph.appendChild( bar ); 62 | 63 | } 64 | 65 | var setMode = function ( value ) { 66 | 67 | mode = value; 68 | 69 | switch ( mode ) { 70 | 71 | case 0: 72 | fpsDiv.style.display = 'block'; 73 | msDiv.style.display = 'none'; 74 | break; 75 | case 1: 76 | fpsDiv.style.display = 'none'; 77 | msDiv.style.display = 'block'; 78 | break; 79 | } 80 | 81 | }; 82 | 83 | var updateGraph = function ( dom, value ) { 84 | 85 | var child = dom.appendChild( dom.firstChild ); 86 | child.style.height = value + 'px'; 87 | 88 | }; 89 | 90 | return { 91 | 92 | REVISION: 12, 93 | 94 | domElement: container, 95 | 96 | setMode: setMode, 97 | 98 | begin: function () { 99 | 100 | startTime = Date.now(); 101 | 102 | }, 103 | 104 | end: function () { 105 | 106 | var time = Date.now(); 107 | 108 | ms = time - startTime; 109 | msMin = Math.min( msMin, ms ); 110 | msMax = Math.max( msMax, ms ); 111 | 112 | msText.textContent = ms + ' MS (' + msMin + '-' + msMax + ')'; 113 | updateGraph( msGraph, Math.min( 30, 30 - ( ms / 200 ) * 30 ) ); 114 | 115 | frames ++; 116 | 117 | if ( time > prevTime + 1000 ) { 118 | 119 | fps = Math.round( ( frames * 1000 ) / ( time - prevTime ) ); 120 | fpsMin = Math.min( fpsMin, fps ); 121 | fpsMax = Math.max( fpsMax, fps ); 122 | 123 | fpsText.textContent = fps + ' FPS (' + fpsMin + '-' + fpsMax + ')'; 124 | updateGraph( fpsGraph, Math.min( 30, 30 - ( fps / 100 ) * 30 ) ); 125 | 126 | prevTime = time; 127 | frames = 0; 128 | 129 | } 130 | 131 | return time; 132 | 133 | }, 134 | 135 | update: function () { 136 | 137 | startTime = this.end(); 138 | 139 | } 140 | 141 | } 142 | 143 | }; 144 | 145 | if ( typeof module === 'object' ) { 146 | 147 | module.exports = Stats; 148 | 149 | } -------------------------------------------------------------------------------- /src/lib/stats.min.js: -------------------------------------------------------------------------------- 1 | // stats.js - http://github.com/mrdoob/stats.js 2 | var Stats=function(){var l=Date.now(),m=l,g=0,n=Infinity,o=0,h=0,p=Infinity,q=0,r=0,s=0,f=document.createElement("div");f.id="stats";f.addEventListener("mousedown",function(b){b.preventDefault();t(++s%2)},!1);f.style.cssText="width:80px;opacity:0.9;cursor:pointer";var a=document.createElement("div");a.id="fps";a.style.cssText="padding:0 0 3px 3px;text-align:left;background-color:#002";f.appendChild(a);var i=document.createElement("div");i.id="fpsText";i.style.cssText="color:#0ff;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px"; 3 | i.innerHTML="FPS";a.appendChild(i);var c=document.createElement("div");c.id="fpsGraph";c.style.cssText="position:relative;width:74px;height:30px;background-color:#0ff";for(a.appendChild(c);74>c.children.length;){var j=document.createElement("span");j.style.cssText="width:1px;height:30px;float:left;background-color:#113";c.appendChild(j)}var d=document.createElement("div");d.id="ms";d.style.cssText="padding:0 0 3px 3px;text-align:left;background-color:#020;display:none";f.appendChild(d);var k=document.createElement("div"); 4 | k.id="msText";k.style.cssText="color:#0f0;font-family:Helvetica,Arial,sans-serif;font-size:9px;font-weight:bold;line-height:15px";k.innerHTML="MS";d.appendChild(k);var e=document.createElement("div");e.id="msGraph";e.style.cssText="position:relative;width:74px;height:30px;background-color:#0f0";for(d.appendChild(e);74>e.children.length;)j=document.createElement("span"),j.style.cssText="width:1px;height:30px;float:left;background-color:#131",e.appendChild(j);var t=function(b){s=b;switch(s){case 0:a.style.display= 5 | "block";d.style.display="none";break;case 1:a.style.display="none",d.style.display="block"}};return{REVISION:12,domElement:f,setMode:t,begin:function(){l=Date.now()},end:function(){var b=Date.now();g=b-l;n=Math.min(n,g);o=Math.max(o,g);k.textContent=g+" MS ("+n+"-"+o+")";var a=Math.min(30,30-30*(g/200));e.appendChild(e.firstChild).style.height=a+"px";r++;b>m+1E3&&(h=Math.round(1E3*r/(b-m)),p=Math.min(p,h),q=Math.max(q,h),i.textContent=h+" FPS ("+p+"-"+q+")",a=Math.min(30,30-30*(h/100)),c.appendChild(c.firstChild).style.height= 6 | a+"px",m=b,r=0);return b},update:function(){l=this.end()}}};"object"===typeof module&&(module.exports=Stats); 7 | -------------------------------------------------------------------------------- /src/models/cube.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-11-24T00:36:19 9 | 2014-11-24T00:36:19 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 0.64 0.64 0.64 1 31 | 32 | 33 | 0.5 0.5 0.5 1 34 | 35 | 36 | 50 37 | 38 | 39 | 1 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | -1 -1 -1 -1 1 -1 1 1 -1 1 -1 -1 -1 -1 1 -1 1 1 1 1 1 1 -1 1 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 3 3 3 3 3 3 3 3 3 3 3 3 81 |

4 0 5 0 1 0 5 1 6 1 2 1 6 2 7 2 3 2 7 3 4 3 0 3 0 4 1 4 2 4 7 5 6 5 5 5 0 6 4 6 1 6 1 7 5 7 2 7 2 8 6 8 3 8 3 9 7 9 0 9 3 10 0 10 2 10 4 11 7 11 5 11

82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | -------------------------------------------------------------------------------- /src/models/cubeshatter.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/src/models/cubeshatter.blend -------------------------------------------------------------------------------- /src/models/donut.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/src/models/donut.blend -------------------------------------------------------------------------------- /src/models/donut.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-07T01:04:13 9 | 2014-12-07T01:04:13 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 1.02 0 0 0.9101651 0 0.265165 0.6450001 0 0.375 0.379835 0 0.265165 0.27 0 0 0.379835 0 -0.265165 0.6450001 0 -0.375 0.9101651 0 -0.265165 0.9031652 0.4740176 0 0.8059112 0.4229748 0.265165 0.5711193 0.2997464 0.375 0.3363271 0.1765181 0.265165 0.2390732 0.1254752 0 0.3363271 0.1765181 -0.265165 0.5711193 0.2997464 -0.375 0.8059112 0.4229748 -0.265165 0.5794259 0.8394436 0 0.5170326 0.7490513 0.265165 0.3664016 0.5308247 0.375 0.2157708 0.3125981 0.265165 0.1533774 0.2222056 0 0.2157708 0.3125981 -0.265165 0.3664016 0.5308247 -0.375 0.5170326 0.7490513 -0.265165 0.1229475 1.012563 0 0.1097084 0.9035289 0.265165 0.07774621 0.6402972 0.375 0.04578411 0.3770655 0.265165 0.03254491 0.2680314 0 0.04578411 0.3770655 -0.265165 0.07774621 0.6402972 -0.375 0.1097084 0.9035289 -0.265165 -0.361697 0.9537165 0 -0.322749 0.851019 0.265165 -0.2287201 0.6030855 0.375 -0.1346913 0.3551518 0.265165 -0.09574329 0.2524544 0 -0.1346913 0.3551518 -0.265165 -0.2287201 0.6030855 -0.375 -0.322749 0.851019 -0.265165 -0.7634813 0.6763849 0 -0.6812685 0.6035509 0.265165 -0.4827895 0.427714 0.375 -0.2843106 0.2518771 0.265165 -0.202098 0.1790431 0 -0.2843106 0.2518771 -0.265165 -0.4827895 0.427714 -0.375 -0.6812685 0.6035509 -0.265165 -0.9903606 0.244102 0 -0.8837172 0.2178167 0.265165 -0.6262574 0.1543586 0.375 -0.3687976 0.09090042 0.265165 -0.2621543 0.06461524 0 -0.3687976 0.09090042 -0.265165 -0.6262574 0.1543586 -0.375 -0.8837172 0.2178167 -0.265165 -0.9903608 -0.2441015 0 -0.8837175 -0.2178163 0.265165 -0.6262575 -0.1543583 0.375 -0.3687977 -0.09090024 0.265165 -0.2621544 -0.06461507 0 -0.3687977 -0.09090024 -0.265165 -0.6262575 -0.1543583 -0.375 -0.8837175 -0.2178163 -0.265165 -0.7634813 -0.6763849 0 -0.6812685 -0.6035508 0.265165 -0.4827895 -0.4277139 0.375 -0.2843106 -0.2518771 0.265165 -0.202098 -0.179043 0 -0.2843106 -0.2518771 -0.265165 -0.4827895 -0.4277139 -0.375 -0.6812685 -0.6035508 -0.265165 -0.361697 -0.9537165 0 -0.322749 -0.851019 0.265165 -0.2287201 -0.6030853 0.375 -0.1346913 -0.3551518 0.265165 -0.09574329 -0.2524544 0 -0.1346913 -0.3551518 -0.265165 -0.2287201 -0.6030853 -0.375 -0.322749 -0.851019 -0.265165 0.1229475 -1.012563 0 0.1097084 -0.9035289 0.265165 0.07774621 -0.6402972 0.375 0.04578411 -0.3770654 0.265165 0.03254491 -0.2680314 0 0.04578411 -0.3770654 -0.265165 0.07774621 -0.6402972 -0.375 0.1097084 -0.9035289 -0.265165 0.5794256 -0.8394439 0 0.5170323 -0.7490515 0.265165 0.3664014 -0.5308248 0.375 0.2157707 -0.3125982 0.265165 0.1533774 -0.2222057 0 0.2157707 -0.3125982 -0.265165 0.3664014 -0.5308248 -0.375 0.5170323 -0.7490515 -0.265165 0.903165 -0.474018 0 0.805911 -0.4229752 0.265165 0.5711191 -0.2997467 0.375 0.336327 -0.1765182 0.265165 0.239073 -0.1254754 0 0.336327 -0.1765182 -0.265165 0.5711191 -0.2997467 -0.375 0.805911 -0.4229752 -0.265165 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 0.900819 0.2220317 0.3731315 0.3809924 0.0939061 0.919797 -0.3809922 -0.09390604 0.9197971 -0.900819 -0.2220322 0.3731312 -0.900819 -0.2220322 -0.3731312 -0.380992 -0.09390634 -0.9197971 0.3809924 0.0939061 -0.919797 0.9008191 0.2220318 -0.3731313 0.6944523 0.6152311 0.3731313 0.2937115 0.2602058 0.9197971 -0.2937118 -0.2602058 0.919797 -0.6944521 -0.6152312 0.3731313 -0.6944521 -0.6152312 -0.3731313 -0.2937118 -0.2602058 -0.919797 0.2937114 0.2602058 -0.919797 0.6944523 0.6152311 -0.3731313 0.3289947 0.8674881 0.3731312 0.1391451 0.3668954 0.919797 -0.139145 -0.3668953 0.919797 -0.3289948 -0.867488 0.3731314 -0.3289948 -0.867488 -0.3731314 -0.139145 -0.3668953 -0.919797 0.1391451 0.3668954 -0.919797 0.3289948 0.8674882 -0.3731312 -0.1118316 0.9210139 0.3731315 -0.04729813 0.3895336 0.919797 0.04729795 -0.3895335 0.9197971 0.1118313 -0.921014 0.3731313 0.1118313 -0.921014 -0.3731313 0.04729795 -0.3895335 -0.9197971 -0.04729813 0.3895336 -0.919797 -0.1118316 0.9210139 -0.3731315 -0.5270382 0.7635468 0.3731316 -0.2229055 0.3229344 0.9197969 0.2229055 -0.3229344 0.919797 0.5270383 -0.7635468 0.3731313 0.5270383 -0.7635468 -0.3731313 0.2229055 -0.3229344 -0.919797 -0.2229055 0.3229344 -0.9197969 -0.5270382 0.7635468 -0.3731316 -0.8215072 0.4311598 0.3731315 -0.3474482 0.1823549 0.9197969 0.3474483 -0.1823549 0.9197969 0.8215071 -0.4311601 0.3731315 0.8215071 -0.4311601 -0.3731315 0.3474483 -0.1823549 -0.9197969 -0.3474482 0.1823549 -0.9197969 -0.8215072 0.4311598 -0.3731315 -0.9277786 3.39817e-7 0.373131 -0.3923944 3.31368e-7 0.9197971 0.3923946 0 0.9197969 0.9277786 0 0.3731312 0.9277786 0 -0.3731312 0.3923946 0 -0.9197969 -0.3923944 3.31368e-7 -0.9197971 -0.9277786 3.39817e-7 -0.373131 -0.821507 -0.4311597 0.3731318 -0.3474482 -0.1823548 0.919797 0.3474484 0.1823546 0.919797 0.8215073 0.4311596 0.3731313 0.8215072 0.43116 -0.3731314 0.3474484 0.1823546 -0.919797 -0.3474482 -0.1823548 -0.919797 -0.8215069 -0.4311602 -0.3731319 -0.5270384 -0.7635467 0.3731315 -0.2229053 -0.3229344 0.9197971 0.2229055 0.3229344 0.919797 0.5270382 0.7635468 0.3731312 0.5270385 0.7635466 -0.3731312 0.2229055 0.3229344 -0.919797 -0.2229053 -0.3229344 -0.9197971 -0.5270384 -0.7635467 -0.3731315 -0.1118314 -0.921014 0.3731312 -0.04729801 -0.3895336 0.919797 0.04729783 0.3895336 0.919797 0.1118313 0.9210141 0.3731311 0.1118313 0.9210141 -0.3731311 0.04729783 0.3895336 -0.919797 -0.04729801 -0.3895336 -0.919797 -0.1118314 -0.921014 -0.3731312 0.3289946 -0.8674881 0.3731315 0.1391449 -0.3668954 0.919797 -0.139145 0.3668955 0.919797 -0.3289941 0.8674882 0.3731315 -0.3289941 0.8674882 -0.3731315 -0.139145 0.3668955 -0.919797 0.1391449 -0.3668954 -0.919797 0.3289946 -0.8674881 -0.3731315 0.694452 -0.6152314 0.3731313 0.2937115 -0.2602059 0.919797 -0.2937114 0.260206 0.919797 -0.694452 0.6152312 0.3731313 -0.694452 0.6152312 -0.3731313 -0.2937114 0.260206 -0.919797 0.2937115 -0.2602059 -0.919797 0.694452 -0.6152314 -0.3731313 0.900819 -0.222032 0.3731313 0.3809924 -0.09390622 0.9197969 -0.3809924 0.09390622 0.9197969 -0.9008188 0.2220323 0.3731314 -0.9008188 0.2220323 -0.3731314 -0.3809924 0.09390622 -0.9197969 0.3809924 -0.09390622 -0.9197969 0.900819 -0.222032 -0.3731313 0.9008191 0.2220318 0.3731313 0.3809924 0.0939061 0.919797 -0.3809924 -0.0939064 0.919797 -0.9008191 -0.2220317 0.3731315 -0.900819 -0.2220317 -0.3731315 -0.3809924 -0.0939061 -0.919797 0.3809924 0.0939061 -0.919797 0.900819 0.2220317 -0.3731315 0.6944521 0.615231 0.3731313 0.2937115 0.2602059 0.919797 -0.2937114 -0.2602058 0.919797 -0.6944522 -0.615231 0.3731312 -0.6944522 -0.615231 -0.3731312 -0.2937114 -0.2602058 -0.919797 0.2937116 0.2602058 -0.919797 0.6944521 0.615231 -0.3731314 0.3289947 0.8674881 0.3731312 0.139145 0.3668953 0.919797 -0.139145 -0.3668953 0.919797 -0.3289948 -0.867488 0.3731313 -0.3289948 -0.867488 -0.3731313 -0.1391451 -0.3668954 -0.919797 0.139145 0.3668953 -0.919797 0.3289947 0.8674881 -0.3731312 -0.1118314 0.921014 0.3731312 -0.04729801 0.3895336 0.919797 0.04729777 -0.3895336 0.919797 0.1118314 -0.921014 0.3731314 0.1118314 -0.9210139 -0.3731313 0.04729777 -0.3895336 -0.919797 -0.04729807 0.3895336 -0.9197969 -0.1118314 0.921014 -0.3731312 -0.5270383 0.7635468 0.3731315 -0.2229055 0.3229345 0.9197971 0.2229055 -0.3229343 0.919797 0.5270383 -0.7635467 0.3731313 0.5270383 -0.7635468 -0.3731313 0.2229056 -0.3229343 -0.919797 -0.2229055 0.3229345 -0.9197971 -0.5270382 0.7635468 -0.3731316 -0.8215071 0.4311599 0.3731318 -0.3474482 0.1823548 0.919797 0.3474482 -0.1823547 0.919797 0.8215073 -0.43116 0.3731314 0.8215072 -0.4311599 -0.3731313 0.3474482 -0.1823547 -0.919797 -0.3474482 0.1823548 -0.919797 -0.821507 0.4311599 -0.3731318 -0.9277785 6.58249e-7 0.3731316 -0.3923947 0 0.9197969 0.3923947 0 0.9197969 0.9277786 -6.05167e-7 0.3731315 0.9277786 -6.41876e-7 -0.3731315 0.3923948 0 -0.9197969 -0.3923947 0 -0.919797 -0.9277785 6.60234e-7 -0.3731316 -0.8215072 -0.4311603 0.3731311 -0.3474479 -0.1823548 0.9197971 0.3474483 0.1823545 0.919797 0.8215072 0.4311601 0.3731312 0.8215073 0.4311597 -0.3731312 0.3474483 0.1823545 -0.919797 -0.3474479 -0.1823548 -0.9197971 -0.8215074 -0.4311598 -0.3731311 -0.5270382 -0.7635467 0.3731318 -0.2229056 -0.3229344 0.9197969 0.2229056 0.3229345 0.919797 0.5270384 0.7635466 0.3731314 0.5270382 0.7635468 -0.3731314 0.2229056 0.3229344 -0.919797 -0.2229056 -0.3229344 -0.9197969 -0.5270382 -0.7635467 -0.3731318 -0.1118316 -0.9210139 0.3731315 -0.04729819 -0.3895334 0.9197971 0.04729783 0.3895336 0.9197969 0.1118311 0.9210141 0.3731312 0.1118311 0.9210141 -0.3731312 0.04729783 0.3895336 -0.919797 -0.04729819 -0.3895334 -0.9197971 -0.1118316 -0.9210139 -0.3731315 0.3289945 -0.8674882 0.3731312 0.1391449 -0.3668953 0.919797 -0.1391447 0.3668954 0.9197971 -0.3289947 0.8674882 0.3731312 -0.3289947 0.8674882 -0.3731312 -0.1391447 0.3668954 -0.919797 0.1391449 -0.3668953 -0.9197969 0.3289945 -0.8674882 -0.3731312 0.6944519 -0.6152312 0.3731313 0.2937114 -0.2602059 0.919797 -0.2937117 0.2602059 0.9197968 -0.6944521 0.615231 0.3731314 -0.6944521 0.615231 -0.3731314 -0.2937117 0.2602059 -0.919797 0.2937114 -0.2602059 -0.919797 0.6944518 -0.6152313 -0.3731313 0.900819 -0.222032 0.3731313 0.3809924 -0.09390622 0.919797 -0.3809922 0.09390634 0.919797 -0.900819 0.2220321 0.3731313 -0.900819 0.2220321 -0.3731313 -0.3809922 0.09390634 -0.919797 0.3809924 -0.09390622 -0.9197969 0.900819 -0.222032 -0.3731313 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 75 |

0 0 8 0 9 0 1 1 9 1 10 1 2 2 10 2 11 2 3 3 11 3 12 3 12 4 13 4 5 4 5 5 13 5 14 5 14 6 15 6 7 6 0 7 7 7 15 7 16 8 17 8 9 8 9 9 17 9 18 9 18 10 19 10 11 10 19 11 20 11 12 11 12 12 20 12 21 12 13 13 21 13 22 13 14 14 22 14 23 14 15 15 23 15 16 15 16 16 24 16 25 16 25 17 26 17 18 17 18 18 26 18 27 18 19 19 27 19 28 19 28 20 29 20 21 20 29 21 30 21 22 21 22 22 30 22 31 22 23 23 31 23 24 23 32 24 33 24 25 24 33 25 34 25 26 25 34 26 35 26 27 26 35 27 36 27 28 27 28 28 36 28 37 28 29 29 37 29 38 29 30 30 38 30 39 30 31 31 39 31 32 31 32 32 40 32 41 32 33 33 41 33 42 33 42 34 43 34 35 34 35 35 43 35 44 35 44 36 45 36 37 36 37 37 45 37 46 37 46 38 47 38 39 38 47 39 40 39 32 39 40 40 48 40 49 40 49 41 50 41 42 41 50 42 51 42 43 42 43 43 51 43 52 43 52 44 53 44 45 44 45 45 53 45 54 45 46 46 54 46 55 46 55 47 48 47 40 47 48 48 56 48 57 48 49 49 57 49 58 49 50 50 58 50 59 50 51 51 59 51 60 51 60 52 61 52 53 52 61 53 62 53 54 53 62 54 63 54 55 54 63 55 56 55 48 55 56 56 64 56 65 56 65 57 66 57 58 57 58 58 66 58 67 58 59 59 67 59 68 59 60 60 68 60 69 60 69 61 70 61 62 61 62 62 70 62 71 62 63 63 71 63 64 63 72 64 73 64 65 64 73 65 74 65 66 65 74 66 75 66 67 66 67 67 75 67 76 67 68 68 76 68 77 68 69 69 77 69 78 69 70 70 78 70 79 70 71 71 79 71 72 71 72 72 80 72 81 72 73 73 81 73 82 73 74 74 82 74 83 74 83 75 84 75 76 75 76 76 84 76 85 76 85 77 86 77 78 77 86 78 87 78 79 78 87 79 80 79 72 79 88 80 89 80 81 80 81 81 89 81 90 81 82 82 90 82 91 82 83 83 91 83 92 83 92 84 93 84 85 84 93 85 94 85 86 85 94 86 95 86 87 86 87 87 95 87 88 87 96 88 97 88 89 88 89 89 97 89 98 89 90 90 98 90 99 90 99 91 100 91 92 91 92 92 100 92 101 92 101 93 102 93 94 93 102 94 103 94 95 94 95 95 103 95 96 95 96 96 0 96 1 96 1 97 2 97 98 97 98 98 2 98 3 98 99 99 3 99 4 99 4 100 5 100 101 100 5 101 6 101 102 101 102 102 6 102 7 102 7 103 0 103 96 103 1 104 0 104 9 104 2 105 1 105 10 105 3 106 2 106 11 106 4 107 3 107 12 107 4 108 12 108 5 108 6 109 5 109 14 109 6 110 14 110 7 110 8 111 0 111 15 111 8 112 16 112 9 112 10 113 9 113 18 113 10 114 18 114 11 114 11 115 19 115 12 115 13 116 12 116 21 116 14 117 13 117 22 117 15 118 14 118 23 118 8 119 15 119 16 119 17 120 16 120 25 120 17 121 25 121 18 121 19 122 18 122 27 122 20 123 19 123 28 123 20 124 28 124 21 124 21 125 29 125 22 125 23 126 22 126 31 126 16 127 23 127 24 127 24 128 32 128 25 128 25 129 33 129 26 129 26 130 34 130 27 130 27 131 35 131 28 131 29 132 28 132 37 132 30 133 29 133 38 133 31 134 30 134 39 134 24 135 31 135 32 135 33 136 32 136 41 136 34 137 33 137 42 137 34 138 42 138 35 138 36 139 35 139 44 139 36 140 44 140 37 140 38 141 37 141 46 141 38 142 46 142 39 142 39 143 47 143 32 143 41 144 40 144 49 144 41 145 49 145 42 145 42 146 50 146 43 146 44 147 43 147 52 147 44 148 52 148 45 148 46 149 45 149 54 149 47 150 46 150 55 150 47 151 55 151 40 151 49 152 48 152 57 152 50 153 49 153 58 153 51 154 50 154 59 154 52 155 51 155 60 155 52 156 60 156 53 156 53 157 61 157 54 157 54 158 62 158 55 158 55 159 63 159 48 159 57 160 56 160 65 160 57 161 65 161 58 161 59 162 58 162 67 162 60 163 59 163 68 163 61 164 60 164 69 164 61 165 69 165 62 165 63 166 62 166 71 166 56 167 63 167 64 167 64 168 72 168 65 168 65 169 73 169 66 169 66 170 74 170 67 170 68 171 67 171 76 171 69 172 68 172 77 172 70 173 69 173 78 173 71 174 70 174 79 174 64 175 71 175 72 175 73 176 72 176 81 176 74 177 73 177 82 177 75 178 74 178 83 178 75 179 83 179 76 179 77 180 76 180 85 180 77 181 85 181 78 181 78 182 86 182 79 182 79 183 87 183 72 183 80 184 88 184 81 184 82 185 81 185 90 185 83 186 82 186 91 186 84 187 83 187 92 187 84 188 92 188 85 188 85 189 93 189 86 189 86 190 94 190 87 190 80 191 87 191 88 191 88 192 96 192 89 192 90 193 89 193 98 193 91 194 90 194 99 194 91 195 99 195 92 195 93 196 92 196 101 196 93 197 101 197 94 197 94 198 102 198 95 198 88 199 95 199 96 199 97 200 96 200 1 200 97 201 1 201 98 201 99 202 98 202 3 202 100 203 99 203 4 203 100 204 4 204 101 204 101 205 5 205 102 205 103 206 102 206 7 206 103 207 7 207 96 207

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 84 | 0 0 0 85 | 0 0 1 0 86 | 0 1 0 0 87 | 1 0 0 0 88 | 1 1 1 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /src/models/icoshatter.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/src/models/icoshatter.blend -------------------------------------------------------------------------------- /src/models/icosphere.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-11-24T14:28:31 9 | 2014-11-24T14:28:31 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 0.5 0.5 0.5 1 34 | 35 | 36 | 50 37 | 38 | 39 | 1 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 0 0 -1 0.7236 -0.52572 -0.447215 -0.276385 -0.85064 -0.447215 -0.894425 0 -0.447215 -0.276385 0.85064 -0.447215 0.7236 0.52572 -0.447215 0.276385 -0.85064 0.447215 -0.7236 -0.52572 0.447215 -0.7236 0.52572 0.447215 0.276385 0.85064 0.447215 0.894425 0 0.447215 0 0 1 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 0.1875965 -0.5773537 -0.794651 0.6070647 0 -0.7946524 -0.4911221 -0.3568291 -0.7946522 -0.4911221 0.3568291 -0.7946522 0.1875965 0.5773537 -0.794651 0.9822461 0 -0.1875967 0.3035355 -0.9341715 -0.1875891 -0.7946492 -0.5773594 -0.1875869 -0.7946492 0.5773594 -0.187587 0.3035355 0.9341715 -0.1875891 0.7946492 -0.5773594 0.187587 -0.3035355 -0.9341715 0.1875891 -0.9822461 0 0.1875967 -0.3035355 0.9341715 0.1875891 0.7946492 0.5773594 0.1875869 0.4911221 -0.3568291 0.7946522 -0.1875965 -0.5773537 0.794651 -0.6070647 0 0.7946524 -0.1875965 0.5773537 0.794651 0.4911221 0.3568291 0.7946522 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 81 |

0 0 1 0 2 0 1 1 0 1 5 1 0 2 2 2 3 2 0 3 3 3 4 3 0 4 4 4 5 4 1 5 5 5 10 5 2 6 1 6 6 6 3 7 2 7 7 7 4 8 3 8 8 8 5 9 4 9 9 9 1 10 10 10 6 10 2 11 6 11 7 11 3 12 7 12 8 12 4 13 8 13 9 13 5 14 9 14 10 14 6 15 10 15 11 15 7 16 6 16 11 16 8 17 7 17 11 17 9 18 8 18 11 18 10 19 9 19 11 19

82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 0 0 0 90 | 0 0 1 0 91 | 0 1 0 0 92 | 1 0 0 0 93 | 1 1 1 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | -------------------------------------------------------------------------------- /src/models/oct.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/src/models/oct.blend -------------------------------------------------------------------------------- /src/models/oct.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-06T18:38:38 9 | 2014-12-06T18:38:38 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 0 0 0 0 2 0 2 0 0 0 0 2 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 0 1 0 0 0 1 1 0 0 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 75 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

76 | 77 | 78 | 79 | 80 | 81 | 82 | 0 0 0 -2 1.50996e-7 0 1.50996e-7 2 0 0 0 2 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | -1 0 0 0 0 1 0 1 0 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 3 3 3 108 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

109 | 110 | 111 | 112 | 113 | 114 | 115 | 0 0 0 2 0 0 0 -2 0 0 0 2 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 1 0 0 0 0 1 0 -1 0 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 3 3 3 141 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

142 | 143 | 144 | 145 | 146 | 147 | 148 | 0 0 0 -3.01992e-7 -2 0 -2 3.01992e-7 0 0 0 2 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | -1.50996e-7 -1 0 0 0 1 -1 1.50996e-7 0 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 3 3 3 174 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

175 | 176 | 177 | 178 | 179 | 180 | 181 | 0 0 0 -6.51683e-7 2 -3.01992e-7 -2 -6.51683e-7 0 0 -3.01992e-7 -2 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | -3.25841e-7 1 -1.50996e-7 0 -1.50996e-7 -1 -1 -3.25841e-7 0 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 3 3 3 207 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

208 | 209 | 210 | 211 | 212 | 213 | 214 | 0 0 0 2 0 0 0 2 -3.01992e-7 0 -3.01992e-7 -2 215 | 216 | 217 | 218 | 219 | 220 | 221 | 222 | 223 | 224 | 1 0 0 0 -1.50996e-7 -1 0 1 -1.50996e-7 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 3 3 3 240 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

241 | 242 | 243 | 244 | 245 | 246 | 247 | 0 0 0 -2 0 0 0 -2 3.01992e-7 0 -3.01992e-7 -2 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | -1 0 0 0 -1.50996e-7 -1 0 -1 1.50996e-7 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 3 3 3 273 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

274 | 275 | 276 | 277 | 278 | 279 | 280 | 0 0 0 0 -2 3.01992e-7 2 0 0 0 -3.01992e-7 -2 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 0 -1 1.50996e-7 0 -1.50996e-7 -1 1 0 0 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 3 3 3 306 |

3 0 2 0 0 0 0 1 2 1 1 1 0 2 1 2 3 2

307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 315 | 0 0 0 316 | 0 0 1 0 317 | 0 1 0 0 318 | 1 0 0 0 319 | 1 1 1 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 330 | 0 0 0 331 | 0 0 1 0 332 | 0 1 0 0 333 | 1 0 0 0 334 | 1 1 1 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 345 | 0 0 0 346 | 0 0 1 0 347 | 0 1 0 0 348 | 1 0 0 0 349 | 1 1 1 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 360 | 0 0 0 361 | 0 0 1 0 362 | 0 1 0 0 363 | 1 0 0 0 364 | 1 1 1 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 375 | 0 0 0 376 | 0 0 1 0 377 | 0 1 0 0 378 | 1 0 0 0 379 | 1 1 1 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 390 | 0 0 0 391 | 0 0 1 0 392 | 0 1 0 0 393 | 1 0 0 0 394 | 1 1 1 395 | 396 | 397 | 398 | 399 | 400 | 401 | 402 | 403 | 404 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 405 | 0 0 0 406 | 0 0 1 0 407 | 0 1 0 0 408 | 1 0 0 0 409 | 1 1 1 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 420 | 0 0 0 421 | 0 0 1 0 422 | 0 1 0 0 423 | 1 0 0 0 424 | 1 1 1 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | -------------------------------------------------------------------------------- /src/models/slice.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-01T18:10:22 9 | 2014-12-01T18:10:22 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -1 -0.01000005 -1 -1 -0.00999993 1 1 -0.00999993 1 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 0 1 0 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 75 |

1 0 2 0 0 0

76 | 77 | 78 | 79 | 80 | 81 | 82 | -1 0.0100001 1 -1 0.009999811 -1 1 0.009999811 -1 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 0 -1 1.47149e-7 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 3 108 |

1 0 2 0 0 0

109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | -------------------------------------------------------------------------------- /src/models/tet.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-11-30T19:35:32 9 | 2014-11-30T19:35:32 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 0 1 -0.5 0 0 0.5 0.8660254 -0.5000001 -0.5 -0.8660255 -0.4999999 -0.5 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 0.8330027 -0.4809412 -0.2732933 0 0 0.9999695 -0.8330027 -0.4809412 -0.2732933 0 0.9619129 -0.2732933 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 3 75 |

2 0 1 1 3 2 0 3 1 1 2 0 3 2 1 1 0 3 0 3 2 0 3 2

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 84 | 0 0 0 85 | 0 0 1 0 86 | 0 1 0 0 87 | 1 0 0 0 88 | 1 1 1 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /src/models/tet1.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-01T02:52:37 9 | 2014-12-01T02:52:37 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -0.5907627 0.3763039 -0.4006971 -0.1341112 -0.5133417 0.5993029 0.8646703 -0.562693 -0.4006971 -0.6762414 -1.353636 -0.4006971 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 0.9607227 -0.04745626 -0.2732933 0 0 0.9999695 -0.5214698 -0.8082827 -0.2732933 -0.4392529 0.8557695 -0.2732933 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 3 75 |

2 0 1 1 3 2 0 3 1 1 2 0 3 2 1 1 0 3 0 3 2 0 3 2

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 84 | 0 0 0 85 | 0 0 1 0 86 | 0 1 0 0 87 | 1 0 0 0 88 | 1 1 1 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /src/models/wall.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/src/models/wall.blend -------------------------------------------------------------------------------- /src/models/wall.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-07T00:33:55 9 | 2014-12-07T00:33:55 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -0.05000001 -2 -2 -0.05000001 2 -2 0.05000001 2 -2 0.05000001 -2 -2 -0.05000001 -2 2 -0.05000001 2 2 0.05000001 2 2 0.05000001 -2 2 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 3 3 3 3 3 3 3 3 3 75 |

4 0 5 0 1 0 5 1 6 1 2 1 6 2 7 2 3 2 7 3 4 3 0 3 0 4 1 4 2 4 7 5 6 5 5 5 0 6 4 6 1 6 1 7 5 7 2 7 2 8 6 8 3 8 3 9 7 9 0 9 3 10 0 10 2 10 4 11 7 11 5 11

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 84 | 0 0 0 85 | 0 0 1 0 86 | 0 1 0 0 87 | 1 0 0 0 88 | 1 1 1 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /src/models/wall3.dae: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Blender User 6 | Blender 2.72.0 commit date:2014-10-21, commit time:11:38, hash:9e963ae 7 | 8 | 2014-12-07T03:19:14 9 | 2014-12-07T03:19:14 10 | 11 | Z_UP 12 | 13 | 14 | 15 | Untitled.png 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 0 0 0 1 25 | 26 | 27 | 0 0 0 1 28 | 29 | 30 | 1 1 1 1 31 | 32 | 33 | 1 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | -0.15 -6 -1.753099 -0.15 6 -1.753099 0.15 6 -1.753099 0.15 -6 -1.753099 -0.15 -6 10.2469 -0.15 6 10.2469 0.15 6 10.2469 0.15 -6 10.2469 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 -1 0 0 0 1 0 1 0 0 0 -1 0 0 0 -1 0 0 1 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 3 3 3 3 3 3 3 3 3 3 3 3 75 |

4 0 5 0 1 0 5 1 6 1 2 1 6 2 7 2 3 2 7 3 4 3 0 3 0 4 1 4 2 4 7 5 6 5 5 5 0 6 4 6 1 6 1 7 5 7 2 7 2 8 6 8 3 8 3 9 7 9 0 9 3 10 0 10 2 10 4 11 7 11 5 11

76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 84 | 0 0 0 85 | 0 0 1 0 86 | 0 1 0 0 87 | 1 0 0 0 88 | 1 1 1 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /testanalysis.blend: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/kainino0x/cis565final/708780b9c9d99b1a93e74d798b36442ca80bd406/testanalysis.blend --------------------------------------------------------------------------------