contrib/bobtoolz/DTrainDrawer.cpp

   1 /*
   2    BobToolz plugin for GtkRadiant
   3    Copyright (C) 2001 Gordon Biggans
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with this library; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 #include "DTrainDrawer.h"
  21
  22 #include <list>
  23 #include "str.h"
  24
  25 #include "DPoint.h"
  26 #include "DPlane.h"
  27 #include "DBrush.h"
  28 #include "DEPair.h"
  29 #include "DPatch.h"
  30 #include "DEntity.h"
  31
  32 #include "misc.h"
  33 #include "funchandlers.h"
  34
  35 #include "iglrender.h"
  36 #include "ientity.h"
  37 #include "math/matrix.h"
  38
  39 #include "dialogs/dialogs-gtk.h"
  40
  41 DTrainDrawer::DTrainDrawer() {
  42         m_bDisplay = false;
  43
  44         BuildPaths();
  45         constructShaders();
  46         GlobalShaderCache().attachRenderable( *this );
  47 }
  48
  49 DTrainDrawer::~DTrainDrawer( void ) {
  50         GlobalShaderCache().detachRenderable( *this );
  51         destroyShaders();
  52
  53         ClearPoints();
  54         ClearSplines();
  55 }
  56
  57 void DTrainDrawer::ClearSplines() {
  58         for ( std::list<splinePoint_t *>::const_iterator deadSpline = m_splineList.begin(); deadSpline != m_splineList.end(); deadSpline++ ) {
  59                 ( *deadSpline )->m_pointList.clear();
  60                 ( *deadSpline )->m_vertexList.clear();
  61                 delete ( *deadSpline );
  62         }
  63
  64         m_splineList.clear();
  65 }
  66
  67 void DTrainDrawer::ClearPoints() {
  68         for ( std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++ ) {
  69                 delete *deadPoint;
  70         }
  71
  72         m_pointList.clear();
  73 }
  74
  75 void CalculateSpline_r( vec3_t* v, int count, vec3_t out, float tension ) {
  76         vec3_t dist;
  77
  78         if ( count < 2 ) {
  79                 return;
  80         }
  81
  82         if ( count == 2 ) {
  83                 VectorSubtract( v[1], v[0], dist );
  84                 VectorMA( v[0], tension, dist, out );
  85                 return;
  86         }
  87
  88         vec3_t* v2 = new vec3_t[count - 1];
  89
  90         for ( int i = 0; i < count - 1; i++ ) {
  91                 VectorSubtract( v[i + 1], v[i], dist );
  92                 VectorMA( v[i], tension, dist, v2[i] );
  93         }
  94
  95         CalculateSpline_r( v2, count - 1, out, tension );
  96
  97         delete[] v2;
  98 }
  99
 100 void DTrainDrawer::render( RenderStateFlags state ) const {
 101         for ( std::list<splinePoint_t* >::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
 102                 splinePoint_t* pSP = ( *sp );
 103
 104                 glBegin( GL_LINE_STRIP );
 105                 for ( std::list<DPoint >::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++ ) {
 106                         glVertex3fv( ( *v )._pnt );
 107                 }
 108                 glEnd();
 109
 110         }
 111 }
 112
 113 const char* DTrainDrawer_state_wireframe = "$bobtoolz/traindrawer/wireframe";
 114 const char* DTrainDrawer_state_solid = "$bobtoolz/traindrawer/solid";
 115
 116 void DTrainDrawer::constructShaders(){
 117         OpenGLState state;
 118         GlobalOpenGLStateLibrary().getDefaultState( state );
 119         state.m_state = RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_BLEND;
 120         state.m_sort = OpenGLState::eSortOverlayFirst;
 121         state.m_linewidth = 1;
 122         state.m_colour[0] = 1;
 123         state.m_colour[1] = 0;
 124         state.m_colour[2] = 0;
 125         state.m_colour[3] = 1;
 126         state.m_linewidth = 1;
 127         GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_wireframe, state );
 128
 129         state.m_colour[0] = 1;
 130         state.m_colour[1] = 1;
 131         state.m_colour[2] = 1;
 132         state.m_colour[3] = 1;
 133         state.m_linewidth = 2;
 134         GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_solid, state );
 135
 136         m_shader_wireframe = GlobalShaderCache().capture( DTrainDrawer_state_wireframe );
 137         m_shader_solid = GlobalShaderCache().capture( DTrainDrawer_state_solid );
 138 }
 139
 140 void DTrainDrawer::destroyShaders(){
 141         GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_wireframe );
 142         GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_solid );
 143         GlobalShaderCache().release( DTrainDrawer_state_wireframe );
 144         GlobalShaderCache().release( DTrainDrawer_state_solid );
 145 }
 146
 147
 148 void DTrainDrawer::renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
 149         if ( !m_bDisplay ) {
 150                 return;
 151         }
 152
 153         renderer.SetState( m_shader_wireframe, Renderer::eWireframeOnly );
 154         renderer.SetState( m_shader_solid, Renderer::eFullMaterials );
 155         renderer.addRenderable( *this, g_matrix4_identity );
 156 }
 157 void DTrainDrawer::renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
 158         renderSolid( renderer, volume );
 159 }
 160
 161 void AddSplineControl( const char* control, splinePoint_t* pSP ) {
 162         controlPoint_t cp;
 163         strncpy( cp.strName, control, 64 );
 164
 165         pSP->m_pointList.push_front( cp );
 166 }
 167
 168 class EntityBuildPaths
 169 {
 170 mutable DEntity e;
 171 DTrainDrawer& drawer;
 172 public:
 173 EntityBuildPaths( DTrainDrawer& drawer ) : drawer( drawer ){
 174 }
 175 void operator()( scene::Instance& instance ) const {
 176         e.ClearEPairs();
 177         e.LoadEPairList( Node_getEntity( instance.path().top() ) );
 178
 179         const char* classname = e.m_Classname.GetBuffer();
 180         const char* target;
 181         const char* control;
 182         const char* targetname;
 183         vec3_t vOrigin;
 184
 185         e.SpawnString( "targetname", NULL, &targetname );
 186         e.SpawnVector( "origin", "0 0 0", vOrigin );
 187
 188         if ( !strcmp( classname, "info_train_spline_main" ) ) {
 189                 if ( !targetname ) {
 190                         globalOutputStream() << "info_train_spline_main with no targetname";
 191                         return;
 192                 }
 193
 194                 e.SpawnString( "target", NULL, &target );
 195
 196                 if ( !target ) {
 197                         drawer.AddControlPoint( targetname, vOrigin );
 198                 }
 199                 else {
 200                         splinePoint_t* pSP = drawer.AddSplinePoint( targetname, target, vOrigin );
 201
 202                         e.SpawnString( "control", NULL, &control );
 203
 204                         if ( control ) {
 205                                 AddSplineControl( control, pSP );
 206
 207                                 for ( int j = 2;; j++ ) {
 208                                         char buffer[16];
 209                                         sprintf( buffer, "control%i", j );
 210
 211                                         e.SpawnString( buffer, NULL, &control );
 212                                         if ( !control ) {
 213                                                 break;
 214                                         }
 215
 216                                         AddSplineControl( control, pSP );
 217                                 }
 218                         }
 219                 }
 220         }
 221         else if ( !strcmp( classname, "info_train_spline_control" ) ) {
 222                 if ( !targetname ) {
 223                         globalOutputStream() << "info_train_spline_control with no targetname";
 224                         return;
 225                 }
 226
 227                 drawer.AddControlPoint( targetname, vOrigin );
 228         }
 229 }
 230 };
 231
 232 void DTrainDrawer::BuildPaths() {
 233         Scene_forEachEntity( EntityBuildPaths( *this ) );
 234
 235         std::list<splinePoint_t* >::const_iterator sp;
 236         for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
 237                 splinePoint_t* pSP = ( *sp );
 238
 239                 controlPoint_t* pTarget = FindControlPoint( pSP->strTarget );
 240
 241                 if ( !pTarget ) {
 242                         globalOutputStream() << "couldn't find target " << pSP->strTarget;
 243                         return;
 244 //                      continue;
 245                 }
 246
 247                 pSP->pTarget = pTarget;
 248
 249
 250                 for ( std::list<controlPoint_t >::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++ ) {
 251                         controlPoint_t* pControl = FindControlPoint( ( *cp ).strName );
 252                         if ( !pControl ) {
 253                                 globalOutputStream() << "couldn't find control " << ( *cp ).strName;
 254                                 return;
 255                         }
 256
 257                         VectorCopy( pControl->vOrigin, ( *cp ).vOrigin );
 258                 }
 259         }
 260
 261         m_bDisplay = true;
 262
 263         for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
 264                 splinePoint_t* pSP = ( *sp );
 265                 DPoint out;
 266
 267                 if ( !pSP->pTarget ) {
 268                         continue;
 269                 }
 270
 271                 std::size_t count = pSP->m_pointList.size() + 2;
 272                 vec3_t* v = new vec3_t[count];
 273
 274                 VectorCopy( pSP->point.vOrigin, v[0] );
 275
 276                 int i = 1;
 277                 for ( std::list<controlPoint_t>::reverse_iterator cp = pSP->m_pointList.rbegin(); cp != pSP->m_pointList.rend(); cp++ ) {
 278                         VectorCopy( ( *cp ).vOrigin, v[i] );
 279                         i++;
 280                 }
 281                 VectorCopy( pSP->pTarget->vOrigin, v[i] );
 282
 283                 for ( float tension = 0.0f; tension <= 1.f; tension += 0.01f ) {
 284                         CalculateSpline_r( v, static_cast<int>( count ), out._pnt, tension );
 285                         pSP->m_vertexList.push_front( out );
 286                 }
 287
 288                 delete[] v;
 289
 290                 VectorCopy( pSP->pTarget->vOrigin, out._pnt );
 291                 pSP->m_vertexList.push_front( out );
 292         }
 293
 294         SceneChangeNotify();
 295 }
 296
 297 void DTrainDrawer::AddControlPoint( const char* name, vec_t* origin ){
 298         controlPoint_t* pCP = new controlPoint_t;
 299
 300         strncpy( pCP->strName, name, 64 );
 301         VectorCopy( origin, pCP->vOrigin );
 302
 303         m_pointList.push_back( pCP );
 304 }
 305
 306 splinePoint_t* DTrainDrawer::AddSplinePoint( const char* name, const char* target, vec_t* origin ){
 307         splinePoint_t* pSP = new splinePoint_t;
 308
 309         strncpy( pSP->point.strName, name,       64 );
 310         strncpy( pSP->strTarget,     target,     64 );
 311         VectorCopy( origin, pSP->point.vOrigin );
 312         m_splineList.push_back( pSP );
 313
 314         return pSP;
 315 }
 316
 317 controlPoint_t* DTrainDrawer::FindControlPoint( const char* name ){
 318         for ( std::list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++ ) {
 319                 if ( !strcmp( name, ( *cp )->strName ) ) {
 320                         return ( *cp );
 321                 }
 322         }
 323
 324         for ( std::list<splinePoint_t*>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
 325                 if ( !strcmp( name, ( *sp )->point.strName ) ) {
 326                         return &( ( *sp )->point );
 327                 }
 328         }
 329
 330         return NULL;
 331 }