mirror of https://github.com/TTimo/GtkRadiant.git
359 lines
8.5 KiB
C++
359 lines
8.5 KiB
C++
/*
|
|
BobToolz plugin for GtkRadiant
|
|
Copyright (C) 2001 Gordon Biggans
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "StdAfx.h"
|
|
#include "DPoint.h"
|
|
|
|
#include "DTrainDrawer.h"
|
|
#include "DEPair.h"
|
|
|
|
#include "misc.h"
|
|
#include "funchandlers.h"
|
|
|
|
#include "dialogs/dialogs-gtk.h"
|
|
|
|
DTrainDrawer::DTrainDrawer() {
|
|
refCount = 1;
|
|
m_bHooked = FALSE;
|
|
m_bDisplay = FALSE;
|
|
|
|
BuildPaths();
|
|
}
|
|
|
|
DTrainDrawer::~DTrainDrawer(void) {
|
|
if(m_bHooked)
|
|
UnRegister();
|
|
|
|
ClearPoints();
|
|
ClearSplines();
|
|
}
|
|
|
|
void DTrainDrawer::ClearSplines() {
|
|
for(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(list<controlPoint_t *>::const_iterator deadPoint = m_pointList.begin(); deadPoint != m_pointList.end(); deadPoint++) {
|
|
delete *deadPoint;
|
|
}
|
|
|
|
m_pointList.clear();
|
|
}
|
|
|
|
void DTrainDrawer::Register() {
|
|
g_QglTable.m_pfnHookGL2DWindow( this );
|
|
g_QglTable.m_pfnHookGL3DWindow( this );
|
|
m_bHooked = TRUE;
|
|
}
|
|
|
|
void DTrainDrawer::UnRegister() {
|
|
g_QglTable.m_pfnUnHookGL2DWindow( this );
|
|
g_QglTable.m_pfnUnHookGL3DWindow( this );
|
|
m_bHooked = FALSE;
|
|
}
|
|
|
|
void CalculateSpline_r(vec3_t* v, int count, vec3_t out, float tension) {
|
|
vec3_t dist;
|
|
|
|
if(count < 2) {
|
|
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];
|
|
|
|
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);
|
|
|
|
delete[] v2;
|
|
}
|
|
|
|
void DTrainDrawer::Draw3D() {
|
|
|
|
if(!m_bDisplay) {
|
|
return;
|
|
}
|
|
|
|
g_QglTable.m_pfn_qglPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
g_QglTable.m_pfn_qglDisable(GL_BLEND);
|
|
g_QglTable.m_pfn_qglDisable(GL_LINE_SMOOTH);
|
|
|
|
g_QglTable.m_pfn_qglPushMatrix();
|
|
|
|
g_QglTable.m_pfn_qglLineWidth(2.0f);
|
|
g_QglTable.m_pfn_qglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
g_QglTable.m_pfn_qglEnable(GL_BLEND);
|
|
g_QglTable.m_pfn_qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
g_QglTable.m_pfn_qglDisable(GL_POLYGON_SMOOTH);
|
|
|
|
g_QglTable.m_pfn_qglDepthFunc(GL_ALWAYS);
|
|
|
|
for(list<splinePoint_t* >::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
|
|
splinePoint_t* pSP = (*sp);
|
|
|
|
g_QglTable.m_pfn_qglBegin(GL_LINE_STRIP);
|
|
for(list<DPoint >::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++) {
|
|
g_QglTable.m_pfn_qglVertex3fv((*v)._pnt);
|
|
}
|
|
g_QglTable.m_pfn_qglEnd();
|
|
|
|
}
|
|
|
|
g_QglTable.m_pfn_qglPopMatrix();
|
|
g_QglTable.m_pfn_qglPopAttrib();
|
|
}
|
|
|
|
void DTrainDrawer::Draw2D(VIEWTYPE vt) {
|
|
|
|
if(!m_bDisplay) {
|
|
return;
|
|
}
|
|
|
|
g_QglTable.m_pfn_qglPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
g_QglTable.m_pfn_qglDisable(GL_BLEND);
|
|
g_QglTable.m_pfn_qglDisable(GL_LINE_SMOOTH);
|
|
|
|
g_QglTable.m_pfn_qglPushMatrix();
|
|
|
|
switch(vt)
|
|
{
|
|
case XY:
|
|
break;
|
|
case XZ:
|
|
g_QglTable.m_pfn_qglRotatef(270.0f, 1.0f, 0.0f, 0.0f);
|
|
break;
|
|
case YZ:
|
|
g_QglTable.m_pfn_qglRotatef(270.0f, 1.0f, 0.0f, 0.0f);
|
|
g_QglTable.m_pfn_qglRotatef(270.0f, 0.0f, 0.0f, 1.0f);
|
|
break;
|
|
}
|
|
|
|
g_QglTable.m_pfn_qglLineWidth(1.0f);
|
|
g_QglTable.m_pfn_qglColor4f(1.0f, 0.0f, 0.0f, 0.5f);
|
|
|
|
g_QglTable.m_pfn_qglEnable(GL_BLEND);
|
|
g_QglTable.m_pfn_qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
g_QglTable.m_pfn_qglDisable(GL_POLYGON_SMOOTH);
|
|
|
|
g_QglTable.m_pfn_qglDepthFunc(GL_ALWAYS);
|
|
|
|
g_QglTable.m_pfn_qglColor4f(1.f, 0.f, 0.f, 1.f);
|
|
|
|
for(list<splinePoint_t* >::const_iterator sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
|
|
splinePoint_t* pSP = (*sp);
|
|
|
|
g_QglTable.m_pfn_qglBegin(GL_LINE_STRIP);
|
|
for(list<DPoint >::const_iterator v = pSP->m_vertexList.begin(); v != pSP->m_vertexList.end(); v++) {
|
|
g_QglTable.m_pfn_qglVertex3fv((*v)._pnt);
|
|
}
|
|
g_QglTable.m_pfn_qglEnd();
|
|
|
|
}
|
|
|
|
g_QglTable.m_pfn_qglPopMatrix();
|
|
g_QglTable.m_pfn_qglPopAttrib();
|
|
}
|
|
|
|
void AddSplineControl(const char* control, splinePoint_t* pSP) {
|
|
controlPoint_t cp;
|
|
strncpy(cp.strName, control, 64);
|
|
|
|
pSP->m_pointList.push_front(cp);
|
|
}
|
|
|
|
void DTrainDrawer::BuildPaths() {
|
|
int count = g_FuncTable.m_pfnGetEntityCount();
|
|
|
|
DEntity e;
|
|
|
|
for(int i = 0; i < count; i++) {
|
|
entity_s* ent = (entity_s*)g_FuncTable.m_pfnGetEntityHandle(i);
|
|
e.ClearEPairs();
|
|
e.LoadEPairList(*g_EntityTable.m_pfnGetEntityKeyValList(ent));
|
|
|
|
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) {
|
|
Sys_Printf( "info_train_spline_main with no targetname" );
|
|
return;
|
|
}
|
|
|
|
e.SpawnString("target", NULL, &target);
|
|
|
|
if(!target) {
|
|
AddControlPoint( targetname, vOrigin );
|
|
} else {
|
|
splinePoint_t* pSP = 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) {
|
|
Sys_Printf( "info_train_spline_control with no targetname" );
|
|
return;
|
|
}
|
|
|
|
AddControlPoint( targetname, vOrigin );
|
|
}
|
|
}
|
|
|
|
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 );
|
|
|
|
if(!pTarget) {
|
|
Sys_Printf( "couldn't find target %s", pSP->strTarget );
|
|
return;
|
|
// continue;
|
|
}
|
|
|
|
pSP->pTarget = pTarget;
|
|
|
|
|
|
for(list<controlPoint_t >::iterator cp = pSP->m_pointList.begin(); cp != pSP->m_pointList.end(); cp++) {
|
|
controlPoint_t* pControl = FindControlPoint( (*cp).strName );
|
|
if(!pControl) {
|
|
Sys_Printf( "couldn't find control %s", (*cp).strName );
|
|
return;
|
|
}
|
|
|
|
VectorCopy(pControl->vOrigin, (*cp).vOrigin);
|
|
}
|
|
}
|
|
|
|
m_bDisplay = TRUE;
|
|
Register();
|
|
|
|
for(sp = m_splineList.begin(); sp != m_splineList.end(); sp++) {
|
|
splinePoint_t* pSP = (*sp);
|
|
DPoint out;
|
|
|
|
if(!pSP->pTarget) {
|
|
continue;
|
|
}
|
|
|
|
int count = pSP->m_pointList.size() + 2;
|
|
vec3_t* v = new vec3_t[count];
|
|
|
|
VectorCopy(pSP->point.vOrigin, v[0]);
|
|
|
|
int i = 1;
|
|
for(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, count, out._pnt, tension);
|
|
pSP->m_vertexList.push_front(out);
|
|
}
|
|
|
|
delete[] v;
|
|
|
|
VectorCopy(pSP->pTarget->vOrigin, out._pnt);
|
|
pSP->m_vertexList.push_front(out);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void DTrainDrawer::AddControlPoint(const char* name, vec_t* origin)
|
|
{
|
|
controlPoint_t* pCP = new controlPoint_t;
|
|
|
|
strncpy(pCP->strName, name, 64);
|
|
VectorCopy( origin, pCP->vOrigin );
|
|
|
|
m_pointList.push_back( pCP );
|
|
}
|
|
|
|
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 );
|
|
|
|
return pSP;
|
|
}
|
|
|
|
controlPoint_t* DTrainDrawer::FindControlPoint(const char* name)
|
|
{
|
|
for(list<controlPoint_t*>::const_iterator cp = m_pointList.begin(); cp != m_pointList.end(); cp++) {
|
|
if(!strcmp(name, (*cp)->strName)) {
|
|
return (*cp);
|
|
}
|
|
}
|
|
|
|
for(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;
|
|
}
|