Line data Source code
1 : /*
2 : * Copyright (c) 2010-2015: G-CSC, Goethe University Frankfurt
3 : * Author: Sebastian Reiter
4 : *
5 : * This file is part of UG4.
6 : *
7 : * UG4 is free software: you can redistribute it and/or modify it under the
8 : * terms of the GNU Lesser General Public License version 3 (as published by the
9 : * Free Software Foundation) with the following additional attribution
10 : * requirements (according to LGPL/GPL v3 §7):
11 : *
12 : * (1) The following notice must be displayed in the Appropriate Legal Notices
13 : * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
14 : *
15 : * (2) The following notice must be displayed at a prominent place in the
16 : * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
17 : *
18 : * (3) The following bibliography is recommended for citation and must be
19 : * preserved in all covered files:
20 : * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
21 : * parallel geometric multigrid solver on hierarchically distributed grids.
22 : * Computing and visualization in science 16, 4 (2013), 151-164"
23 : * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
24 : * flexible software system for simulating pde based models on high performance
25 : * computers. Computing and visualization in science 16, 4 (2013), 165-179"
26 : *
27 : * This program is distributed in the hope that it will be useful,
28 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 : * GNU Lesser General Public License for more details.
31 : */
32 :
33 : #include "collision_triangles_node.h"
34 :
35 : namespace ug{
36 : namespace node_tree
37 : {
38 :
39 : ////////////////////////////////////////////////////////////////////////
40 0 : SPCollisionTrianglesNode CollisionTrianglesNode::create()
41 : {
42 0 : CollisionTrianglesNode* node = new CollisionTrianglesNode;
43 0 : node->m_objectCode = OC_COLLISION_TRIANGLES_NODE;
44 0 : return SPCollisionTrianglesNode(node);
45 : }
46 :
47 : ////////////////////////////////////////////////////////////////////////
48 0 : CollisionTrianglesNode::CollisionTrianglesNode()
49 : {
50 0 : m_bTriangleIDsSupplied = false;
51 0 : }
52 :
53 : ////////////////////////////////////////////////////////////////////////
54 0 : CollisionTrianglesNode::~CollisionTrianglesNode()
55 : {
56 0 : }
57 :
58 : ////////////////////////////////////////////////////////////////////////
59 0 : void CollisionTrianglesNode::add_triangle(int ind1, int ind2, int ind3)
60 : {
61 0 : if(m_bTriangleIDsSupplied)
62 : {
63 0 : add_triangle(ind1, ind2, ind3);
64 : }
65 : else
66 : {
67 0 : m_vTris.push_back(ind1);
68 0 : m_vTris.push_back(ind2);
69 0 : m_vTris.push_back(ind3);
70 : }
71 0 : }
72 :
73 : ////////////////////////////////////////////////////////////////////////
74 0 : void CollisionTrianglesNode::add_triangle(int ind1, int ind2, int ind3,
75 : CollisionElementID triID)
76 : {
77 0 : m_vTris.push_back(ind1);
78 0 : m_vTris.push_back(ind2);
79 0 : m_vTris.push_back(ind3);
80 :
81 0 : if(!m_bTriangleIDsSupplied)
82 : {
83 0 : m_bTriangleIDsSupplied = true;
84 0 : if(num_triangles() > 0)
85 0 : m_vTriIDs.resize(num_triangles());
86 : }
87 :
88 0 : m_vTriIDs.push_back(triID);
89 0 : }
90 :
91 : ////////////////////////////////////////////////////////////////////////
92 0 : void CollisionTrianglesNode::add_triangles(int* pIndices, size_t numTris)
93 : {
94 0 : size_t maxTri = m_vTris.size() / 3;
95 :
96 0 : if(m_bTriangleIDsSupplied)
97 0 : m_vTriIDs.resize(maxTri + numTris);
98 :
99 : size_t startInd = m_vTris.size();
100 :
101 : // resize m_vTris
102 0 : m_vTris.resize(m_vTris.size() + numTris * 3);
103 :
104 : size_t numInds = numTris * 3;
105 0 : for(size_t i = 0; i < numInds; ++i)
106 0 : m_vTris[startInd + i] = pIndices[i];
107 0 : }
108 :
109 : ////////////////////////////////////////////////////////////////////////
110 0 : void CollisionTrianglesNode::
111 : add_triangles(int* pIndices, CollisionElementID* pTriIDs, size_t numTris)
112 : {
113 0 : size_t maxTri = m_vTris.size() / 3;
114 :
115 0 : if(m_bTriangleIDsSupplied)
116 0 : m_vTriIDs.resize(maxTri + numTris);
117 : else
118 : {
119 0 : m_vTriIDs.resize(maxTri + numTris);
120 0 : m_bTriangleIDsSupplied = true;
121 : }
122 :
123 :
124 : // fill the ids
125 : {
126 0 : for(size_t i = 0; i < numTris; ++i)
127 0 : m_vTriIDs[maxTri + i] = pTriIDs[i];
128 : }
129 :
130 : size_t startInd = m_vTris.size();
131 :
132 : // resize m_vTris
133 0 : m_vTris.resize(m_vTris.size() + numTris * 3);
134 :
135 : // fill m_vEdges
136 : {
137 : size_t numInds = numTris * 3;
138 0 : for(size_t i = 0; i < numInds; ++i)
139 0 : m_vTris[startInd + i] = pIndices[i];
140 : }
141 :
142 0 : }
143 :
144 : ////////////////////////////////////////////////////////////////////////
145 0 : size_t CollisionTrianglesNode::num_triangles() const
146 : {
147 0 : return(m_vTris.size() / 3);
148 : }
149 :
150 : ////////////////////////////////////////////////////////////////////////
151 0 : void CollisionTrianglesNode::
152 : get_triangle(size_t index, int& ind1Out, int& ind2Out, int& ind3Out) const
153 : {
154 0 : index *= 3;
155 0 : ind1Out = m_vTris[index++];
156 0 : ind2Out = m_vTris[index++];
157 0 : ind3Out = m_vTris[index];
158 0 : }
159 :
160 : ////////////////////////////////////////////////////////////////////////
161 0 : const int* CollisionTrianglesNode::get_triangles() const
162 : {
163 0 : return &m_vTris.front();
164 : }
165 :
166 : ////////////////////////////////////////////////////////////////////////
167 0 : void CollisionTrianglesNode::
168 : set_triangle_id(size_t triInd, CollisionElementID triID)
169 : {
170 0 : if(!m_bTriangleIDsSupplied)
171 : {
172 0 : m_bTriangleIDsSupplied = true;
173 0 : if(num_triangles() > 0)
174 0 : m_vTriIDs.resize(num_triangles());
175 : }
176 :
177 0 : if(triInd >= m_vTriIDs.size())
178 0 : m_vTriIDs.resize(triInd + 1);
179 :
180 0 : m_vTriIDs[triInd] = triID;
181 0 : }
182 :
183 : ////////////////////////////////////////////////////////////////////////
184 : CollisionElementID
185 0 : CollisionTrianglesNode::get_triangle_id(size_t triInd)
186 : {
187 0 : if(m_bTriangleIDsSupplied)
188 0 : return m_vTriIDs[triInd];
189 :
190 0 : return CollisionElementID();
191 : }
192 :
193 : }// end of namespace node_tree
194 : }// end of namespace ug
195 :
|
