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 "math/matrix.h"
  37
  38 #include "dialogs/dialogs-gtk.h"
  39
  40 DTrainDrawer::DTrainDrawer() {
  41         m_bDisplay = false;
  42
  43         BuildPaths();
  44   constructShaders();
  45   GlobalShaderCache().attachRenderable(*this);
  46 }
  47
  48 DTrainDrawer::~DTrainDrawer(void) {
  49   GlobalShaderCache().detachRenderable(*this);
  50   destroyShaders();
  51
  52         ClearPoints();
  53         ClearSplines();
  54 }
  55
  56 void DTrainDrawer::ClearSplines() {
  57         for(std::list<splinePoint_t *>::const_iterator deadSpline = m_splineList.begin(); deadSpline != m_splineList.end(); deadSpline++) {
  58                 (*deadSpline)->m_pointList.clear();
  59                 (*deadSpline)->m_vertexList.clear();
  60                 delete (*deadSpline);
  61         }
  62
  63         m_splineList.clear();
  64 }
  65
  66 void DTrainDrawer::ClearPoints() {
  67         for(std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++) {
  68                 delete *deadPoint;
  69         }
  70
  71         m_pointList.clear();
  72 }
  73
  74 void CalculateSpline_r(vec3_t* v, int count, vec3_t out, float tension) {
  75         vec3_t dist;
  76
  77         if(count < 2) {
  78                 return;
  79         }
  80
  81         if(count == 2) {
  82                 VectorSubtract( v[1], v[0], dist );
  83                 VectorMA(v[0], tension, dist, out);
  84                 return;
  85         }
  86
  87         vec3_t* v2 = new vec3_t[count-1];
  88
  89         for( int i = 0; i < count-1; i++ ) {
  90                 VectorSubtract( v[i+1], v[i], dist );
  91                 VectorMA(v[i], tension, dist, v2[i]);
  92         }
  93
  94         CalculateSpline_r( v2, count-1, out, tension);
  95
  96         delete[] v2;
  97 }
  98
  99 void DTrainDrawer::render(RenderStateFlags state) const
 100 {
 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 {
 118   OpenGLState state;
 119   GlobalOpenGLStateLibrary().getDefaultState(state);
 120   state.m_state = RENDER_COLOURWRITE|RENDER_DEPTHWRITE|RENDER_BLEND;
 121   state.m_sort = OpenGLState::eSortOverlayFirst;
 122   state.m_linewidth = 1;
 123   state.m_colour[0] = 1;
 124   state.m_colour[1] = 0;
 125   state.m_colour[2] = 0;
 126   state.m_colour[3] = 1;
 127   state.m_linewidth = 1;
 128   GlobalOpenGLStateLibrary().insert(DTrainDrawer_state_wireframe, state);
 129
 130   state.m_colour[0] = 1;
 131   state.m_colour[1] = 1;
 132   state.m_colour[2] = 1;
 133   state.m_colour[3] = 1;
 134   state.m_linewidth = 2;
 135   GlobalOpenGLStateLibrary().insert(DTrainDrawer_state_solid, state);
 136
 137   m_shader_wireframe = GlobalShaderCache().capture(DTrainDrawer_state_wireframe);
 138   m_shader_solid = GlobalShaderCache().capture(DTrainDrawer_state_solid);
 139 }
 140
 141 void DTrainDrawer::destroyShaders()
 142 {
 143   GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_wireframe);
 144   GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_solid);
 145   GlobalShaderCache().release(DTrainDrawer_state_wireframe);
 146   GlobalShaderCache().release(DTrainDrawer_state_solid);
 147 }
 148
 149
 150 void DTrainDrawer::renderSolid(Renderer& renderer, const VolumeTest& volume) const
 151 {
 152         if(!m_bDisplay) {
 153                 return;
 154         }
 155
 156   renderer.SetState(m_shader_wireframe, Renderer::eWireframeOnly);
 157   renderer.SetState(m_shader_solid, Renderer::eFullMaterials);
 158   renderer.addRenderable(*this, g_matrix4_identity);
 159 }
 160 void DTrainDrawer::renderWireframe(Renderer& renderer, const VolumeTest& volume) const
 161 {
 162   renderSolid(renderer, volume);
 163 }
 164
 165 void AddSplineControl(const char* control, splinePoint_t* pSP) {
 166         controlPoint_t cp;
 167         strncpy(cp.strName,     control, 64);
 168
 169         pSP->m_pointList.push_front(cp);
 170 }
 171
 172 void DTrainDrawer::BuildPaths() {
 173 #if 0
 174         int count = g_FuncTable.m_pfnGetEntityCount();
 175
 176         DEntity e;
 177
 178         for(int i = 0; i < count; i++) {
 179                 entity_s* ent = (entity_s*)g_FuncTable.m_pfnGetEntityHandle(i);
 180                 e.ClearEPairs();
 181                 e.LoadEPairList(*g_EntityTable.m_pfnGetEntityKeyValList(ent));
 182
 183                 const char* classname = e.m_Classname.GetBuffer();
 184                 const char* target;
 185                 const char* control;
 186                 const char* targetname;
 187                 vec3_t          vOrigin;
 188
 189                 e.SpawnString("targetname", NULL, &targetname);
 190                 e.SpawnVector("origin", "0 0 0", vOrigin);
 191
 192                 if(!strcmp(classname, "info_train_spline_main")) {
 193                         if(!targetname) {
 194                                 Sys_Printf( "info_train_spline_main with no targetname" );
 195                                 return;
 196                         }
 197
 198                         e.SpawnString("target", NULL, &target);
 199
 200                         if(!target) {
 201                                 AddControlPoint( targetname, vOrigin );
 202                         } else {
 203                                 splinePoint_t* pSP = AddSplinePoint( targetname, target, vOrigin );
 204
 205                                 e.SpawnString("control", NULL, &control);
 206
 207                                 if(control) {
 208                                         AddSplineControl( control, pSP );
 209
 210                                         for(int j = 2;; j++) {
 211                                                 char buffer[16];
 212                                                 sprintf(buffer, "control%i", j);
 213
 214                                                 e.SpawnString(buffer, NULL, &control);
 215                                                 if(!control) {
 216                                                         break;
 217                                                 }
 218
 219                                                 AddSplineControl( control, pSP );
 220                                         }
 221                                 }
 222                         }
 223                 } else if(!strcmp(classname, "info_train_spline_control")) {
 224                         if(!targetname) {
 225                                 Sys_Printf( "info_train_spline_control with no targetname" );
 226                                 return;
 227                         }
 228
 229                         AddControlPoint( targetname, vOrigin );
 230                 }
 231         }
 232
 233   std::list<splinePoint_t* >::const_iterator sp;
 234         for(sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
 235                 splinePoint_t* pSP = (*sp);
 236
 237                 controlPoint_t* pTarget = FindControlPoint( pSP->strTarget );
 238
 239                 if(!pTarget) {
 240                         Sys_Printf( "couldn't find target %s", pSP->strTarget );
 241                         return;
 242 //                      continue;
 243                 }
 244
 245                 pSP->pTarget = pTarget;
 246
 247
 248                 for(std::list<controlPoint_t >::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++) {
 249                         controlPoint_t* pControl = FindControlPoint( (*cp).strName );
 250                         if(!pControl) {
 251                                 Sys_Printf( "couldn't find control %s", (*cp).strName );
 252                                 return;
 253                         }
 254
 255                         VectorCopy(pControl->vOrigin, (*cp).vOrigin);
 256                 }
 257         }
 258
 259         m_bDisplay = TRUE;
 260         Register();
 261
 262         for(sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
 263                 splinePoint_t* pSP = (*sp);
 264                 DPoint out;
 265
 266                 if(!pSP->pTarget) {
 267                         continue;
 268                 }
 269
 270                 int count = pSP->m_pointList.size() + 2;
 271                 vec3_t* v = new vec3_t[count];
 272
 273                 VectorCopy(pSP->point.vOrigin, v[0]);
 274
 275                 int i = 1;
 276                 for(std::list<controlPoint_t>::reverse_iterator cp = pSP->m_pointList.rbegin(); cp != pSP->m_pointList.rend(); cp++) {
 277                         VectorCopy((*cp).vOrigin, v[i]);
 278                         i++;
 279                 }
 280                 VectorCopy(pSP->pTarget->vOrigin, v[i]);
 281
 282                 for (float tension = 0.0f; tension <= 1.f; tension += 0.01f) {
 283                         CalculateSpline_r(v, count, out._pnt, tension);
 284                         pSP->m_vertexList.push_front(out);
 285                 }
 286
 287                 delete[] v;
 288
 289                 VectorCopy(pSP->pTarget->vOrigin, out._pnt);
 290                 pSP->m_vertexList.push_front(out);
 291         }
 292
 293 #endif
 294 }
 295
 296 void DTrainDrawer::AddControlPoint(const char* name, vec_t* origin)
 297 {
 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 {
 308         splinePoint_t* pSP = new splinePoint_t;
 309
 310         strncpy(pSP->point.strName, name,               64);
 311         strncpy(pSP->strTarget,         target,         64);
 312         VectorCopy( origin, pSP->point.vOrigin );
 313         m_splineList.push_back( pSP );
 314
 315         return pSP;
 316 }
 317
 318 controlPoint_t* DTrainDrawer::FindControlPoint(const char* name)
 319 {
 320         for(std::list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++) {
 321                 if(!strcmp(name, (*cp)->strName)) {
 322                         return (*cp);
 323                 }
 324         }
 325
 326         for(std::list<splinePoint_t*>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
 327                 if(!strcmp(name, (*sp)->point.strName)) {
 328                         return &((*sp)->point);
 329                 }
 330         }
 331
 332         return NULL;
 333 }