1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #if !defined( INCLUDED_CURVE_H )
23 #define INCLUDED_CURVE_H
24
25 #include "ientity.h"
26 #include "selectable.h"
27 #include "renderable.h"
28
29 #include <set>
30
31 #include "math/curve.h"
32 #include "stream/stringstream.h"
33 #include "signal/signal.h"
34 #include "selectionlib.h"
35 #include "render.h"
36 #include "stringio.h"
37
38 class RenderableCurve : public OpenGLRenderable
39 {
40 public:
41 std::vector<PointVertex> m_vertices;
render(RenderStateFlags state)42 void render( RenderStateFlags state ) const {
43 pointvertex_gl_array( &m_vertices.front() );
44 glDrawArrays( GL_LINE_STRIP, 0, GLsizei( m_vertices.size() ) );
45 }
46 };
47
plotBasisFunction(std::size_t numSegments,int point,int degree)48 inline void plotBasisFunction( std::size_t numSegments, int point, int degree ){
49 Knots knots;
50 KnotVector_openUniform( knots, 4, degree );
51
52 globalOutputStream() << "plotBasisFunction point " << point << " of 4, knot vector:";
53 for ( Knots::iterator i = knots.begin(); i != knots.end(); ++i )
54 {
55 globalOutputStream() << " " << *i;
56 }
57 globalOutputStream() << "\n";
58 globalOutputStream() << "t=0 basis=" << BSpline_basis( knots, point, degree, 0.0 ) << "\n";
59 for ( std::size_t i = 1; i < numSegments; ++i )
60 {
61 double t = ( 1.0 / double(numSegments) ) * double(i);
62 globalOutputStream() << "t=" << t << " basis=" << BSpline_basis( knots, point, degree, t ) << "\n";
63 }
64 globalOutputStream() << "t=1 basis=" << BSpline_basis( knots, point, degree, 1.0 ) << "\n";
65 }
66
ControlPoints_parse(ControlPoints & controlPoints,const char * value)67 inline bool ControlPoints_parse( ControlPoints& controlPoints, const char* value ){
68 StringTokeniser tokeniser( value, " " );
69
70 std::size_t size;
71 if ( !string_parse_size( tokeniser.getToken(), size ) ) {
72 return false;
73 }
74
75 if ( size < 3 ) {
76 return false;
77 }
78 controlPoints.resize( size );
79
80 if ( !string_equal( tokeniser.getToken(), "(" ) ) {
81 return false;
82 }
83 for ( ControlPoints::iterator i = controlPoints.begin(); i != controlPoints.end(); ++i )
84 {
85 if ( !string_parse_float( tokeniser.getToken(), ( *i ).x() )
86 || !string_parse_float( tokeniser.getToken(), ( *i ).y() )
87 || !string_parse_float( tokeniser.getToken(), ( *i ).z() ) ) {
88 return false;
89 }
90 }
91 if ( !string_equal( tokeniser.getToken(), ")" ) ) {
92 return false;
93 }
94 return true;
95 }
96
ControlPoints_write(const ControlPoints & controlPoints,StringOutputStream & value)97 inline void ControlPoints_write( const ControlPoints& controlPoints, StringOutputStream& value ){
98 value << Unsigned( controlPoints.size() ) << " (";
99 for ( ControlPoints::const_iterator i = controlPoints.begin(); i != controlPoints.end(); ++i )
100 {
101 value << " " << ( *i ).x() << " " << ( *i ).y() << " " << ( *i ).z() << " ";
102 }
103 value << ")";
104 }
105
ControlPoint_testSelect(const Vector3 & point,ObservedSelectable & selectable,Selector & selector,SelectionTest & test)106 inline void ControlPoint_testSelect( const Vector3& point, ObservedSelectable& selectable, Selector& selector, SelectionTest& test ){
107 SelectionIntersection best;
108 test.TestPoint( point, best );
109 if ( best.valid() ) {
110 Selector_add( selector, selectable, best );
111 }
112 }
113
114 class ControlPointTransform
115 {
116 const Matrix4& m_matrix;
117 public:
ControlPointTransform(const Matrix4 & matrix)118 ControlPointTransform( const Matrix4& matrix ) : m_matrix( matrix ){
119 }
operator()120 void operator()( Vector3& point ) const {
121 matrix4_transform_point( m_matrix, point );
122 }
123 };
124
125 class ControlPointSnap
126 {
127 float m_snap;
128 public:
ControlPointSnap(float snap)129 ControlPointSnap( float snap ) : m_snap( snap ){
130 }
operator()131 void operator()( Vector3& point ) const {
132 vector3_snap( point, m_snap );
133 }
134 };
135
136 class ControlPointAdd
137 {
138 RenderablePointVector& m_points;
139 public:
ControlPointAdd(RenderablePointVector & points)140 ControlPointAdd( RenderablePointVector& points ) : m_points( points ){
141 }
operator()142 void operator()( const Vector3& point ) const {
143 m_points.push_back( PointVertex( vertex3f_for_vector3( point ), colour_vertex ) );
144 }
145 };
146
147 class ControlPointAddSelected
148 {
149 RenderablePointVector& m_points;
150 public:
ControlPointAddSelected(RenderablePointVector & points)151 ControlPointAddSelected( RenderablePointVector& points ) : m_points( points ){
152 }
operator()153 void operator()( const Vector3& point ) const {
154 m_points.push_back( PointVertex( vertex3f_for_vector3( point ), colour_selected ) );
155 }
156 };
157
158 class CurveEditType
159 {
160 public:
161 Shader* m_controlsShader;
162 Shader* m_selectedShader;
163 };
164
ControlPoints_write(ControlPoints & controlPoints,const char * key,Entity & entity)165 inline void ControlPoints_write( ControlPoints& controlPoints, const char* key, Entity& entity ){
166 StringOutputStream value( 256 );
167 if ( !controlPoints.empty() ) {
168 ControlPoints_write( controlPoints, value );
169 }
170 entity.setKeyValue( key, value.c_str() );
171 }
172
173 class CurveEdit
174 {
175 SelectionChangeCallback m_selectionChanged;
176 ControlPoints& m_controlPoints;
177 typedef Array<ObservedSelectable> Selectables;
178 Selectables m_selectables;
179
180 RenderablePointVector m_controlsRender;
181 mutable RenderablePointVector m_selectedRender;
182
183 public:
184 typedef Static<CurveEditType> Type;
185
CurveEdit(ControlPoints & controlPoints,const SelectionChangeCallback & selectionChanged)186 CurveEdit( ControlPoints& controlPoints, const SelectionChangeCallback& selectionChanged ) :
187 m_selectionChanged( selectionChanged ),
188 m_controlPoints( controlPoints ),
189 m_controlsRender( GL_POINTS ),
190 m_selectedRender( GL_POINTS ){
191 }
192
193 template<typename Functor>
forEachSelected(const Functor & functor)194 const Functor& forEachSelected( const Functor& functor ){
195 ASSERT_MESSAGE( m_controlPoints.size() == m_selectables.size(), "curve instance mismatch" );
196 ControlPoints::iterator p = m_controlPoints.begin();
197 for ( Selectables::iterator i = m_selectables.begin(); i != m_selectables.end(); ++i, ++p )
198 {
199 if ( ( *i ).isSelected() ) {
200 functor( *p );
201 }
202 }
203 return functor;
204 }
205 template<typename Functor>
forEachSelected(const Functor & functor)206 const Functor& forEachSelected( const Functor& functor ) const {
207 ASSERT_MESSAGE( m_controlPoints.size() == m_selectables.size(), "curve instance mismatch" );
208 ControlPoints::const_iterator p = m_controlPoints.begin();
209 for ( Selectables::const_iterator i = m_selectables.begin(); i != m_selectables.end(); ++i, ++p )
210 {
211 if ( ( *i ).isSelected() ) {
212 functor( *p );
213 }
214 }
215 return functor;
216 }
217 template<typename Functor>
forEach(const Functor & functor)218 const Functor& forEach( const Functor& functor ) const {
219 for ( ControlPoints::const_iterator i = m_controlPoints.begin(); i != m_controlPoints.end(); ++i )
220 {
221 functor( *i );
222 }
223 return functor;
224 }
225
testSelect(Selector & selector,SelectionTest & test)226 void testSelect( Selector& selector, SelectionTest& test ){
227 ASSERT_MESSAGE( m_controlPoints.size() == m_selectables.size(), "curve instance mismatch" );
228 ControlPoints::const_iterator p = m_controlPoints.begin();
229 for ( Selectables::iterator i = m_selectables.begin(); i != m_selectables.end(); ++i, ++p )
230 {
231 ControlPoint_testSelect( *p, *i, selector, test );
232 }
233 }
234
isSelected()235 bool isSelected() const {
236 for ( Selectables::const_iterator i = m_selectables.begin(); i != m_selectables.end(); ++i )
237 {
238 if ( ( *i ).isSelected() ) {
239 return true;
240 }
241 }
242 return false;
243 }
setSelected(bool selected)244 void setSelected( bool selected ){
245 for ( Selectables::iterator i = m_selectables.begin(); i != m_selectables.end(); ++i )
246 {
247 ( *i ).setSelected( selected );
248 }
249 }
250
write(const char * key,Entity & entity)251 void write( const char* key, Entity& entity ){
252 ControlPoints_write( m_controlPoints, key, entity );
253 }
254
transform(const Matrix4 & matrix)255 void transform( const Matrix4& matrix ){
256 forEachSelected( ControlPointTransform( matrix ) );
257 }
snapto(float snap)258 void snapto( float snap ){
259 forEachSelected( ControlPointSnap( snap ) );
260 }
261
updateSelected()262 void updateSelected() const {
263 m_selectedRender.clear();
264 forEachSelected( ControlPointAddSelected( m_selectedRender ) );
265 }
266
renderComponents(Renderer & renderer,const VolumeTest & volume,const Matrix4 & localToWorld)267 void renderComponents( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
268 renderer.SetState( Type::instance().m_controlsShader, Renderer::eWireframeOnly );
269 renderer.SetState( Type::instance().m_controlsShader, Renderer::eFullMaterials );
270 renderer.addRenderable( m_controlsRender, localToWorld );
271 }
272
renderComponentsSelected(Renderer & renderer,const VolumeTest & volume,const Matrix4 & localToWorld)273 void renderComponentsSelected( Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld ) const {
274 updateSelected();
275 if ( !m_selectedRender.empty() ) {
276 renderer.Highlight( Renderer::ePrimitive, false );
277 renderer.SetState( Type::instance().m_selectedShader, Renderer::eWireframeOnly );
278 renderer.SetState( Type::instance().m_selectedShader, Renderer::eFullMaterials );
279 renderer.addRenderable( m_selectedRender, localToWorld );
280 }
281 }
282
curveChanged()283 void curveChanged(){
284 m_selectables.resize( m_controlPoints.size(), m_selectionChanged );
285
286 m_controlsRender.clear();
287 m_controlsRender.reserve( m_controlPoints.size() );
288 forEach( ControlPointAdd( m_controlsRender ) );
289
290 m_selectedRender.reserve( m_controlPoints.size() );
291 }
292 typedef MemberCaller<CurveEdit, &CurveEdit::curveChanged> CurveChangedCaller;
293 };
294
295
296
297 const int NURBS_degree = 3;
298
299 class NURBSCurve
300 {
301 Signal0 m_curveChanged;
302 Callback m_boundsChanged;
303 public:
304 ControlPoints m_controlPoints;
305 ControlPoints m_controlPointsTransformed;
306 NURBSWeights m_weights;
307 Knots m_knots;
308 RenderableCurve m_renderCurve;
309 AABB m_bounds;
310
NURBSCurve(const Callback & boundsChanged)311 NURBSCurve( const Callback& boundsChanged ) : m_boundsChanged( boundsChanged ){
312 }
313
connect(const SignalHandler & curveChanged)314 SignalHandlerId connect( const SignalHandler& curveChanged ){
315 curveChanged();
316 return m_curveChanged.connectLast( curveChanged );
317 }
disconnect(SignalHandlerId id)318 void disconnect( SignalHandlerId id ){
319 m_curveChanged.disconnect( id );
320 }
notify()321 void notify(){
322 m_curveChanged();
323 }
324
tesselate()325 void tesselate(){
326 if ( !m_controlPointsTransformed.empty() ) {
327 const std::size_t numSegments = ( m_controlPointsTransformed.size() - 1 ) * 16;
328 m_renderCurve.m_vertices.resize( numSegments + 1 );
329 m_renderCurve.m_vertices[0].vertex = vertex3f_for_vector3( m_controlPointsTransformed[0] );
330 for ( std::size_t i = 1; i < numSegments; ++i )
331 {
332 m_renderCurve.m_vertices[i].vertex = vertex3f_for_vector3( NURBS_evaluate( m_controlPointsTransformed, m_weights, m_knots, NURBS_degree, ( 1.0 / double(numSegments) ) * double(i) ) );
333 }
334 m_renderCurve.m_vertices[numSegments].vertex = vertex3f_for_vector3( m_controlPointsTransformed[m_controlPointsTransformed.size() - 1] );
335 }
336 else
337 {
338 m_renderCurve.m_vertices.clear();
339 }
340 }
341
curveChanged()342 void curveChanged(){
343 tesselate();
344
345 m_bounds = AABB();
346 for ( ControlPoints::iterator i = m_controlPointsTransformed.begin(); i != m_controlPointsTransformed.end(); ++i )
347 {
348 aabb_extend_by_point_safe( m_bounds, ( *i ) );
349 }
350
351 m_boundsChanged();
352 notify();
353 }
354
parseCurve(const char * value)355 bool parseCurve( const char* value ){
356 if ( !ControlPoints_parse( m_controlPoints, value ) ) {
357 return false;
358 }
359
360 m_weights.resize( m_controlPoints.size() );
361 for ( NURBSWeights::iterator i = m_weights.begin(); i != m_weights.end(); ++i )
362 {
363 ( *i ) = 1;
364 }
365
366 KnotVector_openUniform( m_knots, m_controlPoints.size(), NURBS_degree );
367
368 //plotBasisFunction(8, 0, NURBS_degree);
369
370 return true;
371 }
372
curveChanged(const char * value)373 void curveChanged( const char* value ){
374 if ( string_empty( value ) || !parseCurve( value ) ) {
375 m_controlPoints.resize( 0 );
376 m_knots.resize( 0 );
377 m_weights.resize( 0 );
378 }
379 m_controlPointsTransformed = m_controlPoints;
380 curveChanged();
381 }
382 typedef MemberCaller1<NURBSCurve, const char*, &NURBSCurve::curveChanged> CurveChangedCaller;
383 };
384
385 class CatmullRomSpline
386 {
387 Signal0 m_curveChanged;
388 Callback m_boundsChanged;
389 public:
390 ControlPoints m_controlPoints;
391 ControlPoints m_controlPointsTransformed;
392 RenderableCurve m_renderCurve;
393 AABB m_bounds;
394
CatmullRomSpline(const Callback & boundsChanged)395 CatmullRomSpline( const Callback& boundsChanged ) : m_boundsChanged( boundsChanged ){
396 }
397
connect(const SignalHandler & curveChanged)398 SignalHandlerId connect( const SignalHandler& curveChanged ){
399 curveChanged();
400 return m_curveChanged.connectLast( curveChanged );
401 }
disconnect(SignalHandlerId id)402 void disconnect( SignalHandlerId id ){
403 m_curveChanged.disconnect( id );
404 }
notify()405 void notify(){
406 m_curveChanged();
407 }
408
tesselate()409 void tesselate(){
410 if ( !m_controlPointsTransformed.empty() ) {
411 const std::size_t numSegments = ( m_controlPointsTransformed.size() - 1 ) * 16;
412 m_renderCurve.m_vertices.resize( numSegments + 1 );
413 m_renderCurve.m_vertices[0].vertex = vertex3f_for_vector3( m_controlPointsTransformed[0] );
414 for ( std::size_t i = 1; i < numSegments; ++i )
415 {
416 m_renderCurve.m_vertices[i].vertex = vertex3f_for_vector3( CatmullRom_evaluate( m_controlPointsTransformed, ( 1.0 / double(numSegments) ) * double(i) ) );
417 }
418 m_renderCurve.m_vertices[numSegments].vertex = vertex3f_for_vector3( m_controlPointsTransformed[m_controlPointsTransformed.size() - 1] );
419 }
420 else
421 {
422 m_renderCurve.m_vertices.clear();
423 }
424 }
425
parseCurve(const char * value)426 bool parseCurve( const char* value ){
427 return ControlPoints_parse( m_controlPoints, value );
428 }
429
curveChanged()430 void curveChanged(){
431 tesselate();
432
433 m_bounds = AABB();
434 for ( ControlPoints::iterator i = m_controlPointsTransformed.begin(); i != m_controlPointsTransformed.end(); ++i )
435 {
436 aabb_extend_by_point_safe( m_bounds, ( *i ) );
437 }
438
439 m_boundsChanged();
440 notify();
441 }
442
curveChanged(const char * value)443 void curveChanged( const char* value ){
444 if ( string_empty( value ) || !parseCurve( value ) ) {
445 m_controlPoints.resize( 0 );
446 }
447 m_controlPointsTransformed = m_controlPoints;
448 curveChanged();
449 }
450 typedef MemberCaller1<CatmullRomSpline, const char*, &CatmullRomSpline::curveChanged> CurveChangedCaller;
451 };
452
453 const char* const curve_Nurbs = "curve_Nurbs";
454 const char* const curve_CatmullRomSpline = "curve_CatmullRomSpline";
455
456
457 #endif
458