2 BobToolz plugin for GtkRadiant
3 Copyright (C) 2001 Gordon Biggans
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.
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.
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
20 #include "DTrainDrawer.h"
33 #include "funchandlers.h"
35 #include "iglrender.h"
36 #include "math/matrix.h"
38 #include "dialogs/dialogs-gtk.h"
40 DTrainDrawer::DTrainDrawer() {
45 GlobalShaderCache().attachRenderable(*this);
48 DTrainDrawer::~DTrainDrawer(void) {
49 GlobalShaderCache().detachRenderable(*this);
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();
66 void DTrainDrawer::ClearPoints() {
67 for(std::list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++) {
74 void CalculateSpline_r(vec3_t* v, int count, vec3_t out, float tension) {
82 VectorSubtract( v[1], v[0], dist );
83 VectorMA(v[0], tension, dist, out);
87 vec3_t* v2 = new vec3_t[count-1];
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]);
94 CalculateSpline_r( v2, count-1, out, tension);
99 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);
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);
113 const char* DTrainDrawer_state_wireframe = "$bobtoolz/traindrawer/wireframe";
114 const char* DTrainDrawer_state_solid = "$bobtoolz/traindrawer/solid";
116 void DTrainDrawer::constructShaders()
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);
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);
137 m_shader_wireframe = GlobalShaderCache().capture(DTrainDrawer_state_wireframe);
138 m_shader_solid = GlobalShaderCache().capture(DTrainDrawer_state_solid);
141 void DTrainDrawer::destroyShaders()
143 GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_wireframe);
144 GlobalOpenGLStateLibrary().erase(DTrainDrawer_state_solid);
145 GlobalShaderCache().release(DTrainDrawer_state_wireframe);
146 GlobalShaderCache().release(DTrainDrawer_state_solid);
150 void DTrainDrawer::renderSolid(Renderer& renderer, const VolumeTest& volume) const
156 renderer.SetState(m_shader_wireframe, Renderer::eWireframeOnly);
157 renderer.SetState(m_shader_solid, Renderer::eFullMaterials);
158 renderer.addRenderable(*this, g_matrix4_identity);
160 void DTrainDrawer::renderWireframe(Renderer& renderer, const VolumeTest& volume) const
162 renderSolid(renderer, volume);
165 void AddSplineControl(const char* control, splinePoint_t* pSP) {
167 strncpy(cp.strName, control, 64);
169 pSP->m_pointList.push_front(cp);
172 void DTrainDrawer::BuildPaths() {
174 int count = g_FuncTable.m_pfnGetEntityCount();
178 for(int i = 0; i < count; i++) {
179 entity_s* ent = (entity_s*)g_FuncTable.m_pfnGetEntityHandle(i);
181 e.LoadEPairList(*g_EntityTable.m_pfnGetEntityKeyValList(ent));
183 const char* classname = e.m_Classname.GetBuffer();
186 const char* targetname;
189 e.SpawnString("targetname", NULL, &targetname);
190 e.SpawnVector("origin", "0 0 0", vOrigin);
192 if(!strcmp(classname, "info_train_spline_main")) {
194 Sys_Printf( "info_train_spline_main with no targetname" );
198 e.SpawnString("target", NULL, &target);
201 AddControlPoint( targetname, vOrigin );
203 splinePoint_t* pSP = AddSplinePoint( targetname, target, vOrigin );
205 e.SpawnString("control", NULL, &control);
208 AddSplineControl( control, pSP );
210 for(int j = 2;; j++) {
212 sprintf(buffer, "control%i", j);
214 e.SpawnString(buffer, NULL, &control);
219 AddSplineControl( control, pSP );
223 } else if(!strcmp(classname, "info_train_spline_control")) {
225 Sys_Printf( "info_train_spline_control with no targetname" );
229 AddControlPoint( targetname, vOrigin );
233 std::list<splinePoint_t* >::const_iterator sp;
234 for(sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
235 splinePoint_t* pSP = (*sp);
237 controlPoint_t* pTarget = FindControlPoint( pSP->strTarget );
240 Sys_Printf( "couldn't find target %s", pSP->strTarget );
245 pSP->pTarget = pTarget;
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 );
251 Sys_Printf( "couldn't find control %s", (*cp).strName );
255 VectorCopy(pControl->vOrigin, (*cp).vOrigin);
262 for(sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
263 splinePoint_t* pSP = (*sp);
270 int count = pSP->m_pointList.size() + 2;
271 vec3_t* v = new vec3_t[count];
273 VectorCopy(pSP->point.vOrigin, v[0]);
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]);
280 VectorCopy(pSP->pTarget->vOrigin, v[i]);
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);
289 VectorCopy(pSP->pTarget->vOrigin, out._pnt);
290 pSP->m_vertexList.push_front(out);
296 void DTrainDrawer::AddControlPoint(const char* name, vec_t* origin)
298 controlPoint_t* pCP = new controlPoint_t;
300 strncpy(pCP->strName, name, 64);
301 VectorCopy( origin, pCP->vOrigin );
303 m_pointList.push_back( pCP );
306 splinePoint_t* DTrainDrawer::AddSplinePoint(const char* name, const char* target, vec_t* origin)
308 splinePoint_t* pSP = new splinePoint_t;
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 );
318 controlPoint_t* DTrainDrawer::FindControlPoint(const char* name)
320 for(std::list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++) {
321 if(!strcmp(name, (*cp)->strName)) {
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);