clockwerk-opensim-stable – Blame information for rev 1
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | vero | 1 | /* The MIT License |
2 | * |
||
3 | * Copyright (c) 2010 Intel Corporation. |
||
4 | * All rights reserved. |
||
5 | * |
||
6 | * Based on the convexdecomposition library from |
||
7 | * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax. |
||
8 | * |
||
9 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
||
10 | * of this software and associated documentation files (the "Software"), to deal |
||
11 | * in the Software without restriction, including without limitation the rights |
||
12 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||
13 | * copies of the Software, and to permit persons to whom the Software is |
||
14 | * furnished to do so, subject to the following conditions: |
||
15 | * |
||
16 | * The above copyright notice and this permission notice shall be included in |
||
17 | * all copies or substantial portions of the Software. |
||
18 | * |
||
19 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
20 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
21 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||
22 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||
23 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||
24 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||
25 | * THE SOFTWARE. |
||
26 | */ |
||
27 | |||
28 | using System; |
||
29 | using System.Collections.Generic; |
||
30 | |||
31 | namespace OpenSim.Region.Physics.ConvexDecompositionDotNet |
||
32 | { |
||
33 | public class HullResult |
||
34 | { |
||
35 | public bool Polygons = true; // true if indices represents polygons, false indices are triangles |
||
36 | public List<float3> OutputVertices = new List<float3>(); |
||
37 | public List<int> Indices; |
||
38 | |||
39 | // If triangles, then indices are array indexes into the vertex list. |
||
40 | // If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc.. |
||
41 | } |
||
42 | |||
43 | public class PHullResult |
||
44 | { |
||
45 | public List<float3> Vertices = new List<float3>(); |
||
46 | public List<int> Indices = new List<int>(); |
||
47 | } |
||
48 | |||
49 | [Flags] |
||
50 | public enum HullFlag : int |
||
51 | { |
||
52 | QF_DEFAULT = 0, |
||
53 | QF_TRIANGLES = (1 << 0), // report results as triangles, not polygons. |
||
54 | QF_SKIN_WIDTH = (1 << 2) // extrude hull based on this skin width |
||
55 | } |
||
56 | |||
57 | public enum HullError : int |
||
58 | { |
||
59 | QE_OK, // success! |
||
60 | QE_FAIL // failed. |
||
61 | } |
||
62 | |||
63 | public class HullDesc |
||
64 | { |
||
65 | public HullFlag Flags; // flags to use when generating the convex hull. |
||
66 | public List<float3> Vertices; |
||
67 | public float NormalEpsilon; // the epsilon for removing duplicates. This is a normalized value, if normalized bit is on. |
||
68 | public float SkinWidth; |
||
69 | public uint MaxVertices; // maximum number of vertices to be considered for the hull! |
||
70 | public uint MaxFaces; |
||
71 | |||
72 | public HullDesc() |
||
73 | { |
||
74 | Flags = HullFlag.QF_DEFAULT; |
||
75 | Vertices = new List<float3>(); |
||
76 | NormalEpsilon = 0.001f; |
||
77 | MaxVertices = 4096; |
||
78 | MaxFaces = 4096; |
||
79 | SkinWidth = 0.01f; |
||
80 | } |
||
81 | |||
82 | public HullDesc(HullFlag flags, List<float3> vertices) |
||
83 | { |
||
84 | Flags = flags; |
||
85 | Vertices = new List<float3>(vertices); |
||
86 | NormalEpsilon = 0.001f; |
||
87 | MaxVertices = 4096; |
||
88 | MaxFaces = 4096; |
||
89 | SkinWidth = 0.01f; |
||
90 | } |
||
91 | |||
92 | public bool HasHullFlag(HullFlag flag) |
||
93 | { |
||
94 | return (Flags & flag) != 0; |
||
95 | } |
||
96 | |||
97 | public void SetHullFlag(HullFlag flag) |
||
98 | { |
||
99 | Flags |= flag; |
||
100 | } |
||
101 | |||
102 | public void ClearHullFlag(HullFlag flag) |
||
103 | { |
||
104 | Flags &= ~flag; |
||
105 | } |
||
106 | } |
||
107 | |||
108 | public class ConvexH |
||
109 | { |
||
110 | public struct HalfEdge |
||
111 | { |
||
112 | public short ea; // the other half of the edge (index into edges list) |
||
113 | public byte v; // the vertex at the start of this edge (index into vertices list) |
||
114 | public byte p; // the facet on which this edge lies (index into facets list) |
||
115 | |||
116 | public HalfEdge(short _ea, byte _v, byte _p) |
||
117 | { |
||
118 | ea = _ea; |
||
119 | v = _v; |
||
120 | p = _p; |
||
121 | } |
||
122 | |||
123 | public HalfEdge(HalfEdge e) |
||
124 | { |
||
125 | ea = e.ea; |
||
126 | v = e.v; |
||
127 | p = e.p; |
||
128 | } |
||
129 | } |
||
130 | |||
131 | public List<float3> vertices = new List<float3>(); |
||
132 | public List<HalfEdge> edges = new List<HalfEdge>(); |
||
133 | public List<Plane> facets = new List<Plane>(); |
||
134 | |||
135 | public ConvexH(int vertices_size, int edges_size, int facets_size) |
||
136 | { |
||
137 | vertices = new List<float3>(vertices_size); |
||
138 | edges = new List<HalfEdge>(edges_size); |
||
139 | facets = new List<Plane>(facets_size); |
||
140 | } |
||
141 | } |
||
142 | |||
143 | public class VertFlag |
||
144 | { |
||
145 | public byte planetest; |
||
146 | public byte junk; |
||
147 | public byte undermap; |
||
148 | public byte overmap; |
||
149 | } |
||
150 | |||
151 | public class EdgeFlag |
||
152 | { |
||
153 | public byte planetest; |
||
154 | public byte fixes; |
||
155 | public short undermap; |
||
156 | public short overmap; |
||
157 | } |
||
158 | |||
159 | public class PlaneFlag |
||
160 | { |
||
161 | public byte undermap; |
||
162 | public byte overmap; |
||
163 | } |
||
164 | |||
165 | public class Coplanar |
||
166 | { |
||
167 | public ushort ea; |
||
168 | public byte v0; |
||
169 | public byte v1; |
||
170 | } |
||
171 | } |