← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/bullet/src/BulletCollision/Gimpact/gim_clip_polygon.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/bullet/src/BulletCollision/Gimpact/gim_clip_polygon.h
 
1
#ifndef GIM_CLIP_POLYGON_H_INCLUDED
 
2
#define GIM_CLIP_POLYGON_H_INCLUDED
 
3
 
 
4
/*! \file gim_tri_collision.h
 
5
\author Francisco Leon Najera
 
6
*/
 
7
/*
 
8
-----------------------------------------------------------------------------
 
9
This source file is part of GIMPACT Library.
 
10
 
 
11
For the latest info, see http://gimpact.sourceforge.net/
 
12
 
 
13
Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
 
14
email: projectileman@yahoo.com
 
15
 
 
16
 This library is free software; you can redistribute it and/or
 
17
 modify it under the terms of EITHER:
 
18
   (1) The GNU Lesser General Public License as published by the Free
 
19
       Software Foundation; either version 2.1 of the License, or (at
 
20
       your option) any later version. The text of the GNU Lesser
 
21
       General Public License is included with this library in the
 
22
       file GIMPACT-LICENSE-LGPL.TXT.
 
23
   (2) The BSD-style license that is included with this library in
 
24
       the file GIMPACT-LICENSE-BSD.TXT.
 
25
   (3) The zlib/libpng license that is included with this library in
 
26
       the file GIMPACT-LICENSE-ZLIB.TXT.
 
27
 
 
28
 This library is distributed in the hope that it will be useful,
 
29
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 
30
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
 
31
 GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
 
32
 
 
33
-----------------------------------------------------------------------------
 
34
*/
 
35
 
 
36
 
 
37
//! This function calcs the distance from a 3D plane
 
38
class DISTANCE_PLANE_3D_FUNC
 
39
{
 
40
public:
 
41
        template<typename CLASS_POINT,typename CLASS_PLANE>
 
42
        inline GREAL operator()(const CLASS_PLANE & plane, const CLASS_POINT & point)
 
43
        {
 
44
                return DISTANCE_PLANE_POINT(plane, point);
 
45
        }
 
46
};
 
47
 
 
48
 
 
49
 
 
50
template<typename CLASS_POINT>
 
51
SIMD_FORCE_INLINE void PLANE_CLIP_POLYGON_COLLECT(
 
52
                                                const CLASS_POINT & point0,
 
53
                                                const CLASS_POINT & point1,
 
54
                                                GREAL dist0,
 
55
                                                GREAL dist1,
 
56
                                                CLASS_POINT * clipped,
 
57
                                                GUINT & clipped_count)
 
58
{
 
59
        GUINT _prevclassif = (dist0>G_EPSILON);
 
60
        GUINT _classif = (dist1>G_EPSILON);
 
61
        if(_classif!=_prevclassif)
 
62
        {
 
63
                GREAL blendfactor = -dist0/(dist1-dist0);
 
64
                VEC_BLEND(clipped[clipped_count],point0,point1,blendfactor);
 
65
                clipped_count++;
 
66
        }
 
67
        if(!_classif)
 
68
        {
 
69
                VEC_COPY(clipped[clipped_count],point1);
 
70
                clipped_count++;
 
71
        }
 
72
}
 
73
 
 
74
 
 
75
//! Clips a polygon by a plane
 
76
/*!
 
77
*\return The count of the clipped counts
 
78
*/
 
79
template<typename CLASS_POINT,typename CLASS_PLANE, typename DISTANCE_PLANE_FUNC>
 
80
SIMD_FORCE_INLINE GUINT PLANE_CLIP_POLYGON_GENERIC(
 
81
                                                const CLASS_PLANE & plane,
 
82
                                                const CLASS_POINT * polygon_points,
 
83
                                                GUINT polygon_point_count,
 
84
                                                CLASS_POINT * clipped,DISTANCE_PLANE_FUNC distance_func)
 
85
{
 
86
    GUINT clipped_count = 0;
 
87
 
 
88
 
 
89
    //clip first point
 
90
        GREAL firstdist = distance_func(plane,polygon_points[0]);;
 
91
        if(!(firstdist>G_EPSILON))
 
92
        {
 
93
                VEC_COPY(clipped[clipped_count],polygon_points[0]);
 
94
                clipped_count++;
 
95
        }
 
96
 
 
97
        GREAL olddist = firstdist;
 
98
        for(GUINT _i=1;_i<polygon_point_count;_i++)
 
99
        {               
 
100
                GREAL dist = distance_func(plane,polygon_points[_i]);
 
101
 
 
102
                PLANE_CLIP_POLYGON_COLLECT(
 
103
                                                polygon_points[_i-1],polygon_points[_i],
 
104
                                                olddist,
 
105
                                                dist,
 
106
                                                clipped,
 
107
                                                clipped_count);
 
108
 
 
109
 
 
110
                olddist = dist;         
 
111
        }
 
112
 
 
113
        //RETURN TO FIRST  point        
 
114
 
 
115
        PLANE_CLIP_POLYGON_COLLECT(
 
116
                                        polygon_points[polygon_point_count-1],polygon_points[0],
 
117
                                        olddist,
 
118
                                        firstdist,
 
119
                                        clipped,
 
120
                                        clipped_count);
 
121
 
 
122
        return clipped_count;
 
123
}
 
124
 
 
125
//! Clips a polygon by a plane
 
126
/*!
 
127
*\return The count of the clipped counts
 
128
*/
 
129
template<typename CLASS_POINT,typename CLASS_PLANE, typename DISTANCE_PLANE_FUNC>
 
130
SIMD_FORCE_INLINE GUINT PLANE_CLIP_TRIANGLE_GENERIC(
 
131
                                                const CLASS_PLANE & plane,
 
132
                                                const CLASS_POINT & point0,
 
133
                                                const CLASS_POINT & point1,
 
134
                                                const CLASS_POINT & point2,
 
135
                                                CLASS_POINT * clipped,DISTANCE_PLANE_FUNC distance_func)
 
136
{
 
137
    GUINT clipped_count = 0;
 
138
 
 
139
    //clip first point
 
140
        GREAL firstdist = distance_func(plane,point0);;
 
141
        if(!(firstdist>G_EPSILON))
 
142
        {
 
143
                VEC_COPY(clipped[clipped_count],point0);
 
144
                clipped_count++;
 
145
        }
 
146
 
 
147
        // point 1
 
148
        GREAL olddist = firstdist;
 
149
        GREAL dist = distance_func(plane,point1);
 
150
 
 
151
        PLANE_CLIP_POLYGON_COLLECT(
 
152
                                        point0,point1,
 
153
                                        olddist,
 
154
                                        dist,
 
155
                                        clipped,
 
156
                                        clipped_count);
 
157
 
 
158
        olddist = dist;
 
159
 
 
160
 
 
161
        // point 2
 
162
        dist = distance_func(plane,point2);
 
163
 
 
164
        PLANE_CLIP_POLYGON_COLLECT(
 
165
                                        point1,point2,
 
166
                                        olddist,
 
167
                                        dist,
 
168
                                        clipped,
 
169
                                        clipped_count);
 
170
        olddist = dist;
 
171
 
 
172
 
 
173
 
 
174
        //RETURN TO FIRST  point
 
175
        PLANE_CLIP_POLYGON_COLLECT(
 
176
                                        point2,point0,
 
177
                                        olddist,
 
178
                                        firstdist,
 
179
                                        clipped,
 
180
                                        clipped_count);
 
181
 
 
182
        return clipped_count;
 
183
}
 
184
 
 
185
 
 
186
template<typename CLASS_POINT,typename CLASS_PLANE>
 
187
SIMD_FORCE_INLINE GUINT PLANE_CLIP_POLYGON3D(
 
188
                                                const CLASS_PLANE & plane,
 
189
                                                const CLASS_POINT * polygon_points,
 
190
                                                GUINT polygon_point_count,
 
191
                                                CLASS_POINT * clipped)
 
192
{
 
193
        return PLANE_CLIP_POLYGON_GENERIC<CLASS_POINT,CLASS_PLANE>(plane,polygon_points,polygon_point_count,clipped,DISTANCE_PLANE_3D_FUNC());
 
194
}
 
195
 
 
196
 
 
197
template<typename CLASS_POINT,typename CLASS_PLANE>
 
198
SIMD_FORCE_INLINE GUINT PLANE_CLIP_TRIANGLE3D(
 
199
                                                const CLASS_PLANE & plane,
 
200
                                                const CLASS_POINT & point0,
 
201
                                                const CLASS_POINT & point1,
 
202
                                                const CLASS_POINT & point2,
 
203
                                                CLASS_POINT * clipped)
 
204
{
 
205
        return PLANE_CLIP_TRIANGLE_GENERIC<CLASS_POINT,CLASS_PLANE>(plane,point0,point1,point2,clipped,DISTANCE_PLANE_3D_FUNC());
 
206
}
 
207
 
 
208
 
 
209
 
 
210
#endif // GIM_TRI_COLLISION_H_INCLUDED