]> git.xonotic.org Git - xonotic/netradiant.git/blobdiff - contrib/bobtoolz/DTrainDrawer.cpp
Revert partially (auto) "reformat code! now the code is only ugly on the *inside*"
[xonotic/netradiant.git] / contrib / bobtoolz / DTrainDrawer.cpp
index 0a3307de978da70294afa257732e591c5c1424cd..da7edcc1bd0ee568892cf4f4dc74653d87108027 100644 (file)
 
 #include "dialogs/dialogs-gtk.h"
 
-DTrainDrawer::DTrainDrawer()
-{
-    m_bDisplay = false;
+DTrainDrawer::DTrainDrawer() {
+       m_bDisplay = false;
 
-    BuildPaths();
-    constructShaders();
-    GlobalShaderCache().attachRenderable(*this);
+       BuildPaths();
+       constructShaders();
+       GlobalShaderCache().attachRenderable( *this );
 }
 
-DTrainDrawer::~DTrainDrawer(void)
-{
-    GlobalShaderCache().detachRenderable(*this);
-    destroyShaders();
+DTrainDrawer::~DTrainDrawer( void ) {
+       GlobalShaderCache().detachRenderable( *this );
+       destroyShaders();
 
-    ClearPoints();
-    ClearSplines();
+       ClearPoints();
+       ClearSplines();
 }
 
-void DTrainDrawer::ClearSplines()
-{
-    for (std::list<splinePoint_t *>::const_iterator deadSpline = m_splineList.begin();
-         deadSpline != m_splineList.end(); deadSpline++) {
-        (*deadSpline)->m_pointList.clear();
-        (*deadSpline)->m_vertexList.clear();
-        delete (*deadSpline);
-    }
-
-    m_splineList.clear();
+void DTrainDrawer::ClearSplines() {
+       for ( std::list<splinePoint_t *>::const_iterator deadSpline = m_splineList.begin(); deadSpline != m_splineList.end(); deadSpline++ ) {
+               ( *deadSpline )->m_pointList.clear();
+               ( *deadSpline )->m_vertexList.clear();
+               delete ( *deadSpline );
+       }
+
+       m_splineList.clear();
 }
 
-void DTrainDrawer::ClearPoints()
-{
-    for (std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin();
-         deadPoint != m_pointList.end(); deadPoint++) {
-        delete *deadPoint;
-    }
+void DTrainDrawer::ClearPoints() {
+       for ( std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++ ) {
+               delete *deadPoint;
+       }
 
-    m_pointList.clear();
+       m_pointList.clear();
 }
 
-void CalculateSpline_r(vec3_t *v, int count, vec3_t out, float tension)
-{
-    vec3_t dist;
+void CalculateSpline_r( vec3_t* v, int count, vec3_t out, float tension ) {
+       vec3_t dist;
 
-    if (count < 2) {
-        return;
-    }
+       if ( count < 2 ) {
+               return;
+       }
 
-    if (count == 2) {
-        VectorSubtract(v[1], v[0], dist);
-        VectorMA(v[0], tension, dist, out);
-        return;
-    }
+       if ( count == 2 ) {
+               VectorSubtract( v[1], v[0], dist );
+               VectorMA( v[0], tension, dist, out );
+               return;
+       }
 
-    vec3_t *v2 = new vec3_t[count - 1];
+       vec3_t* v2 = new vec3_t[count - 1];
 
-    for (int i = 0; i < count - 1; i++) {
-        VectorSubtract(v[i + 1], v[i], dist);
-        VectorMA(v[i], tension, dist, v2[i]);
-    }
+       for ( int i = 0; i < count - 1; i++ ) {
+               VectorSubtract( v[i + 1], v[i], dist );
+               VectorMA( v[i], tension, dist, v2[i] );
+       }
 
-    CalculateSpline_r(v2, count - 1, out, tension);
+       CalculateSpline_r( v2, count - 1, out, tension );
 
-    delete[] v2;
+       delete[] v2;
 }
 
-void DTrainDrawer::render(RenderStateFlags state) const
-{
-    for (std::list<splinePoint_t *>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
-        splinePoint_t *pSP = (*sp);
+void DTrainDrawer::render( RenderStateFlags state ) const {
+       for ( std::list<splinePoint_t* >::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
+               splinePoint_t* pSP = ( *sp );
 
-        glBegin(GL_LINE_STRIP);
-        for (std::list<DPoint>::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++) {
-            glVertex3fv((*v)._pnt);
-        }
-        glEnd();
+               glBegin( GL_LINE_STRIP );
+               for ( std::list<DPoint >::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++ ) {
+                       glVertex3fv( ( *v )._pnt );
+               }
+               glEnd();
 
-    }
+       }
 }
 
-const char *DTrainDrawer_state_wireframe = "$bobtoolz/traindrawer/wireframe";
-const char *DTrainDrawer_state_solid = "$bobtoolz/traindrawer/solid";
-
-void DTrainDrawer::constructShaders()
-{
-    OpenGLState state;
-    GlobalOpenGLStateLibrary().getDefaultState(state);
-    state.m_state = RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_BLEND;
-    state.m_sort = OpenGLState::eSortOverlayFirst;
-    state.m_linewidth = 1;
-    state.m_colour[0] = 1;
-    state.m_colour[1] = 0;
-    state.m_colour[2] = 0;
-    state.m_colour[3] = 1;
-    state.m_linewidth = 1;
-    GlobalOpenGLStateLibrary().insert(DTrainDrawer_state_wireframe, state);
-
-    state.m_colour[0] = 1;
-    state.m_colour[1] = 1;
-    state.m_colour[2] = 1;
-    state.m_colour[3] = 1;
-    state.m_linewidth = 2;
-    GlobalOpenGLStateLibrary().insert(DTrainDrawer_state_solid, state);
-
-    m_shader_wireframe = GlobalShaderCache().capture(DTrainDrawer_state_wireframe);
-    m_shader_solid = GlobalShaderCache().capture(DTrainDrawer_state_solid);
+const char* DTrainDrawer_state_wireframe = "$bobtoolz/traindrawer/wireframe";
+const char* DTrainDrawer_state_solid = "$bobtoolz/traindrawer/solid";
+
+void DTrainDrawer::constructShaders(){
+       OpenGLState state;
+       GlobalOpenGLStateLibrary().getDefaultState( state );
+       state.m_state = RENDER_COLOURWRITE | RENDER_DEPTHWRITE | RENDER_BLEND;
+       state.m_sort = OpenGLState::eSortOverlayFirst;
+       state.m_linewidth = 1;
+       state.m_colour[0] = 1;
+       state.m_colour[1] = 0;
+       state.m_colour[2] = 0;
+       state.m_colour[3] = 1;
+       state.m_linewidth = 1;
+       GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_wireframe, state );
+
+       state.m_colour[0] = 1;
+       state.m_colour[1] = 1;
+       state.m_colour[2] = 1;
+       state.m_colour[3] = 1;
+       state.m_linewidth = 2;
+       GlobalOpenGLStateLibrary().insert( DTrainDrawer_state_solid, state );
+
+       m_shader_wireframe = GlobalShaderCache().capture( DTrainDrawer_state_wireframe );
+       m_shader_solid = GlobalShaderCache().capture( DTrainDrawer_state_solid );
 }
 
-void DTrainDrawer::destroyShaders()
-{
-    GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_wireframe);
-    GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_solid);
-    GlobalShaderCache().release(DTrainDrawer_state_wireframe);
-    GlobalShaderCache().release(DTrainDrawer_state_solid);
+void DTrainDrawer::destroyShaders(){
+       GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_wireframe );
+       GlobalOpenGLStateLibrary().erase( DTrainDrawer_state_solid );
+       GlobalShaderCache().release( DTrainDrawer_state_wireframe );
+       GlobalShaderCache().release( DTrainDrawer_state_solid );
 }
 
 
-void DTrainDrawer::renderSolid(Renderer &renderer, const VolumeTest &volume) const
-{
-    if (!m_bDisplay) {
-        return;
-    }
+void DTrainDrawer::renderSolid( Renderer& renderer, const VolumeTest& volume ) const {
+       if ( !m_bDisplay ) {
+               return;
+       }
 
-    renderer.SetState(m_shader_wireframe, Renderer::eWireframeOnly);
-    renderer.SetState(m_shader_solid, Renderer::eFullMaterials);
-    renderer.addRenderable(*this, g_matrix4_identity);
+       renderer.SetState( m_shader_wireframe, Renderer::eWireframeOnly );
+       renderer.SetState( m_shader_solid, Renderer::eFullMaterials );
+       renderer.addRenderable( *this, g_matrix4_identity );
 }
-
-void DTrainDrawer::renderWireframe(Renderer &renderer, const VolumeTest &volume) const
-{
-    renderSolid(renderer, volume);
+void DTrainDrawer::renderWireframe( Renderer& renderer, const VolumeTest& volume ) const {
+       renderSolid( renderer, volume );
 }
 
-void AddSplineControl(const char *control, splinePoint_t *pSP)
-{
-    controlPoint_t cp;
-    strncpy(cp.strName, control, 64);
+void AddSplineControl( const char* control, splinePoint_t* pSP ) {
+       controlPoint_t cp;
+       strncpy( cp.strName, control, 64 );
 
-    pSP->m_pointList.push_front(cp);
+       pSP->m_pointList.push_front( cp );
 }
 
-class EntityBuildPaths {
-    mutable DEntity e;
-    DTrainDrawer &drawer;
+class EntityBuildPaths
+{
+mutable DEntity e;
+DTrainDrawer& drawer;
 public:
-    EntityBuildPaths(DTrainDrawer &drawer) : drawer(drawer)
-    {
-    }
-
-    void operator()(scene::Instance &instance) const
-    {
-        e.ClearEPairs();
-        e.LoadEPairList(Node_getEntity(instance.path().top()));
-
-        const char *classname = e.m_Classname.GetBuffer();
-        const char *target;
-        const char *control;
-        const char *targetname;
-        vec3_t vOrigin;
-
-        e.SpawnString("targetname", NULL, &targetname);
-        e.SpawnVector("origin", "0 0 0", vOrigin);
-
-        if (!strcmp(classname, "info_train_spline_main")) {
-            if (!targetname) {
-                globalOutputStream() << "info_train_spline_main with no targetname";
-                return;
-            }
-
-            e.SpawnString("target", NULL, &target);
-
-            if (!target) {
-                drawer.AddControlPoint(targetname, vOrigin);
-            } else {
-                splinePoint_t *pSP = drawer.AddSplinePoint(targetname, target, vOrigin);
-
-                e.SpawnString("control", NULL, &control);
-
-                if (control) {
-                    AddSplineControl(control, pSP);
-
-                    for (int j = 2;; j++) {
-                        char buffer[16];
-                        sprintf(buffer, "control%i", j);
-
-                        e.SpawnString(buffer, NULL, &control);
-                        if (!control) {
-                            break;
-                        }
-
-                        AddSplineControl(control, pSP);
-                    }
-                }
-            }
-        } else if (!strcmp(classname, "info_train_spline_control")) {
-            if (!targetname) {
-                globalOutputStream() << "info_train_spline_control with no targetname";
-                return;
-            }
-
-            drawer.AddControlPoint(targetname, vOrigin);
-        }
-    }
+EntityBuildPaths( DTrainDrawer& drawer ) : drawer( drawer ){
+}
+void operator()( scene::Instance& instance ) const {
+       e.ClearEPairs();
+       e.LoadEPairList( Node_getEntity( instance.path().top() ) );
+
+       const char* classname = e.m_Classname.GetBuffer();
+       const char* target;
+       const char* control;
+       const char* targetname;
+       vec3_t vOrigin;
+
+       e.SpawnString( "targetname", NULL, &targetname );
+       e.SpawnVector( "origin", "0 0 0", vOrigin );
+
+       if ( !strcmp( classname, "info_train_spline_main" ) ) {
+               if ( !targetname ) {
+                       globalOutputStream() << "info_train_spline_main with no targetname";
+                       return;
+               }
+
+               e.SpawnString( "target", NULL, &target );
+
+               if ( !target ) {
+                       drawer.AddControlPoint( targetname, vOrigin );
+               }
+               else {
+                       splinePoint_t* pSP = drawer.AddSplinePoint( targetname, target, vOrigin );
+
+                       e.SpawnString( "control", NULL, &control );
+
+                       if ( control ) {
+                               AddSplineControl( control, pSP );
+
+                               for ( int j = 2;; j++ ) {
+                                       char buffer[16];
+                                       sprintf( buffer, "control%i", j );
+
+                                       e.SpawnString( buffer, NULL, &control );
+                                       if ( !control ) {
+                                               break;
+                                       }
+
+                                       AddSplineControl( control, pSP );
+                               }
+                       }
+               }
+       }
+       else if ( !strcmp( classname, "info_train_spline_control" ) ) {
+               if ( !targetname ) {
+                       globalOutputStream() << "info_train_spline_control with no targetname";
+                       return;
+               }
+
+               drawer.AddControlPoint( targetname, vOrigin );
+       }
+}
 };
 
-void DTrainDrawer::BuildPaths()
-{
-    Scene_forEachEntity(EntityBuildPaths(*this));
+void DTrainDrawer::BuildPaths() {
+       Scene_forEachEntity( EntityBuildPaths( *this ) );
 
-    std::list<splinePoint_t *>::const_iterator sp;
-    for (sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
-        splinePoint_t *pSP = (*sp);
+       std::list<splinePoint_t* >::const_iterator sp;
+       for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
+               splinePoint_t* pSP = ( *sp );
 
-        controlPoint_t *pTarget = FindControlPoint(pSP->strTarget);
+               controlPoint_t* pTarget = FindControlPoint( pSP->strTarget );
 
-        if (!pTarget) {
-            globalOutputStream() << "couldn't find target " << pSP->strTarget;
-            return;
+               if ( !pTarget ) {
+                       globalOutputStream() << "couldn't find target " << pSP->strTarget;
+                       return;
 //                     continue;
-        }
+               }
 
-        pSP->pTarget = pTarget;
+               pSP->pTarget = pTarget;
 
 
-        for (std::list<controlPoint_t>::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++) {
-            controlPoint_t *pControl = FindControlPoint((*cp).strName);
-            if (!pControl) {
-                globalOutputStream() << "couldn't find control " << (*cp).strName;
-                return;
-            }
+               for ( std::list<controlPoint_t >::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++ ) {
+                       controlPoint_t* pControl = FindControlPoint( ( *cp ).strName );
+                       if ( !pControl ) {
+                               globalOutputStream() << "couldn't find control " << ( *cp ).strName;
+                               return;
+                       }
 
-            VectorCopy(pControl->vOrigin, (*cp).vOrigin);
-        }
-    }
+                       VectorCopy( pControl->vOrigin, ( *cp ).vOrigin );
+               }
+       }
 
-    m_bDisplay = true;
+       m_bDisplay = true;
 
-    for (sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
-        splinePoint_t *pSP = (*sp);
-        DPoint out;
+       for ( sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
+               splinePoint_t* pSP = ( *sp );
+               DPoint out;
 
-        if (!pSP->pTarget) {
-            continue;
-        }
+               if ( !pSP->pTarget ) {
+                       continue;
+               }
 
-        std::size_t count = pSP->m_pointList.size() + 2;
-        vec3_t *v = new vec3_t[count];
+               std::size_t count = pSP->m_pointList.size() + 2;
+               vec3_t* v = new vec3_t[count];
 
-        VectorCopy(pSP->point.vOrigin, v[0]);
+               VectorCopy( pSP->point.vOrigin, v[0] );
 
-        int i = 1;
-        for (std::list<controlPoint_t>::reverse_iterator cp = pSP->m_pointList.rbegin();
-             cp != pSP->m_pointList.rend(); cp++) {
-            VectorCopy((*cp).vOrigin, v[i]);
-            i++;
-        }
-        VectorCopy(pSP->pTarget->vOrigin, v[i]);
+               int i = 1;
+               for ( std::list<controlPoint_t>::reverse_iterator cp = pSP->m_pointList.rbegin(); cp != pSP->m_pointList.rend(); cp++ ) {
+                       VectorCopy( ( *cp ).vOrigin, v[i] );
+                       i++;
+               }
+               VectorCopy( pSP->pTarget->vOrigin, v[i] );
 
-        for (float tension = 0.0f; tension <= 1.f; tension += 0.01f) {
-            CalculateSpline_r(v, static_cast<int>( count ), out._pnt, tension);
-            pSP->m_vertexList.push_front(out);
-        }
+               for ( float tension = 0.0f; tension <= 1.f; tension += 0.01f ) {
+                       CalculateSpline_r( v, static_cast<int>( count ), out._pnt, tension );
+                       pSP->m_vertexList.push_front( out );
+               }
 
-        delete[] v;
+               delete[] v;
 
-        VectorCopy(pSP->pTarget->vOrigin, out._pnt);
-        pSP->m_vertexList.push_front(out);
-    }
+               VectorCopy( pSP->pTarget->vOrigin, out._pnt );
+               pSP->m_vertexList.push_front( out );
+       }
 
-    SceneChangeNotify();
+       SceneChangeNotify();
 }
 
-void DTrainDrawer::AddControlPoint(const char *name, vec_t *origin)
-{
-    controlPoint_t *pCP = new controlPoint_t;
+void DTrainDrawer::AddControlPoint( const char* name, vec_t* origin ){
+       controlPoint_t* pCP = new controlPoint_t;
 
-    strncpy(pCP->strName, name, 64);
-    VectorCopy(origin, pCP->vOrigin);
+       strncpy( pCP->strName, name, 64 );
+       VectorCopy( origin, pCP->vOrigin );
 
-    m_pointList.push_back(pCP);
+       m_pointList.push_back( pCP );
 }
 
-splinePoint_t *DTrainDrawer::AddSplinePoint(const char *name, const char *target, vec_t *origin)
-{
-    splinePoint_t *pSP = new splinePoint_t;
+splinePoint_t* DTrainDrawer::AddSplinePoint( const char* name, const char* target, vec_t* origin ){
+       splinePoint_t* pSP = new splinePoint_t;
 
-    strncpy(pSP->point.strName, name, 64);
-    strncpy(pSP->strTarget, target, 64);
-    VectorCopy(origin, pSP->point.vOrigin);
-    m_splineList.push_back(pSP);
+       strncpy( pSP->point.strName, name,       64 );
+       strncpy( pSP->strTarget,     target,     64 );
+       VectorCopy( origin, pSP->point.vOrigin );
+       m_splineList.push_back( pSP );
 
-    return pSP;
+       return pSP;
 }
 
-controlPoint_t *DTrainDrawer::FindControlPoint(const char *name)
-{
-    for (std::list<controlPoint_t *>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++) {
-        if (!strcmp(name, (*cp)->strName)) {
-            return (*cp);
-        }
-    }
-
-    for (std::list<splinePoint_t *>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
-        if (!strcmp(name, (*sp)->point.strName)) {
-            return &((*sp)->point);
-        }
-    }
-
-    return NULL;
+controlPoint_t* DTrainDrawer::FindControlPoint( const char* name ){
+       for ( std::list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++ ) {
+               if ( !strcmp( name, ( *cp )->strName ) ) {
+                       return ( *cp );
+               }
+       }
+
+       for ( std::list<splinePoint_t*>::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++ ) {
+               if ( !strcmp( name, ( *sp )->point.strName ) ) {
+                       return &( ( *sp )->point );
+               }
+       }
+
+       return NULL;
 }