plugins/entity/curve.h

   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;
  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
  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
  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
  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
 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:
 118 ControlPointTransform( const Matrix4& matrix ) : m_matrix( matrix ){
 119 }
 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:
 129 ControlPointSnap( float snap ) : m_snap( snap ){
 130 }
 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:
 140 ControlPointAdd( RenderablePointVector& points ) : m_points( points ){
 141 }
 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:
 151 ControlPointAddSelected( RenderablePointVector& points ) : m_points( points ){
 152 }
 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
 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
 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>
 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>
 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>
 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
 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
 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 }
 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
 251 void write( const char* key, Entity& entity ){
 252         ControlPoints_write( m_controlPoints, key, entity );
 253 }
 254
 255 void transform( const Matrix4& matrix ){
 256         forEachSelected( ControlPointTransform( matrix ) );
 257 }
 258 void snapto( float snap ){
 259         forEachSelected( ControlPointSnap( snap ) );
 260 }
 261
 262 void updateSelected() const {
 263         m_selectedRender.clear();
 264         forEachSelected( ControlPointAddSelected( m_selectedRender ) );
 265 }
 266
 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
 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
 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
 311 NURBSCurve( const Callback& boundsChanged ) : m_boundsChanged( boundsChanged ){
 312 }
 313
 314 SignalHandlerId connect( const SignalHandler& curveChanged ){
 315         curveChanged();
 316         return m_curveChanged.connectLast( curveChanged );
 317 }
 318 void disconnect( SignalHandlerId id ){
 319         m_curveChanged.disconnect( id );
 320 }
 321 void notify(){
 322         m_curveChanged();
 323 }
 324
 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
 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
 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
 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
 395 CatmullRomSpline( const Callback& boundsChanged ) : m_boundsChanged( boundsChanged ){
 396 }
 397
 398 SignalHandlerId connect( const SignalHandler& curveChanged ){
 399         curveChanged();
 400         return m_curveChanged.connectLast( curveChanged );
 401 }
 402 void disconnect( SignalHandlerId id ){
 403         m_curveChanged.disconnect( id );
 404 }
 405 void notify(){
 406         m_curveChanged();
 407 }
 408
 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
 426 bool parseCurve( const char* value ){
 427         return ControlPoints_parse( m_controlPoints, value );
 428 }
 429
 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
 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