contrib/bobtoolz/DTreePlanter.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 "DTreePlanter.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 "ScriptParser.h"
  33 #include "misc.h"
  34 #include "scenelib.h"
  35
  36
  37
  38 #include "funchandlers.h"
  39
  40 SignalHandlerResult DTreePlanter::mouseDown(const WindowVector& position, ButtonIdentifier button, ModifierFlags modifiers)
  41 {
  42   if(button != c_buttonLeft)
  43   {
  44     return SIGNAL_CONTINUE_EMISSION;
  45   }
  46         VIEWTYPE vt = GlobalRadiant().XYWindow_getViewType();
  47
  48         switch(vt) {
  49                 case XY:
  50                         break;
  51                 case YZ:
  52                 case XZ:
  53                 default:
  54                         return SIGNAL_CONTINUE_EMISSION;
  55         }
  56
  57         Vector3 pt, vhit;
  58
  59   pt = vector3_snapped(GlobalRadiant().XYWindow_windowToWorld(position), GlobalRadiant().getGridSize());
  60
  61         if(FindDropPoint(vector3_to_array(pt), vector3_to_array(vhit))) {
  62                 vhit[2] += m_offset;
  63
  64                 char buffer[128];
  65                 DEntity e(m_entType);
  66
  67                 sprintf(buffer, "%i %i %i", (int)vhit[0], (int)vhit[1], (int)vhit[2]);
  68                 e.AddEPair("origin", buffer);
  69
  70                 if(m_autoLink) {
  71
  72       const scene::Path* pLastEntity = NULL;
  73                         const scene::Path* pThisEntity = NULL;
  74
  75                         int entpos;
  76                         for(int i = 0; i < 256; i++) {
  77                                 sprintf(buffer, m_linkName, i);
  78         pThisEntity = FindEntityFromTargetname( buffer );
  79
  80                                 if(pThisEntity) {
  81                                         entpos = i;
  82                                         pLastEntity = pThisEntity;
  83                                 }
  84                         }
  85
  86                         if(!pLastEntity) {
  87                                 sprintf(buffer, m_linkName, 0);
  88                         } else {
  89                                 sprintf(buffer, m_linkName, entpos + 1);
  90                         }
  91
  92                         e.AddEPair( "targetname", buffer );
  93
  94                         if(pLastEntity) {
  95                                 DEntity e2;
  96                                 e2.LoadFromEntity(pLastEntity->top(), true);
  97                                 e2.AddEPair("target", buffer);
  98                                 e2.RemoveFromRadiant();
  99                                 e2.BuildInRadiant(false);
 100                         }
 101
 102                 }
 103
 104                 if(m_setAngles) {
 105                         int angleYaw = (rand() % (m_maxYaw - m_minYaw + 1)) + m_minYaw;
 106                         int anglePitch = (rand() % (m_maxPitch - m_minPitch + 1)) + m_minPitch;
 107
 108                         sprintf(buffer, "%i %i 0", anglePitch, angleYaw);
 109                         e.AddEPair("angles", buffer);
 110                 }
 111
 112                 if(m_numModels) {
 113                         int treetype = rand() % m_numModels;
 114                         e.AddEPair("model", m_trees[treetype].name);
 115                 }
 116
 117                 if(m_useScale) {
 118                         float scale = (((rand()%1000)*0.001f) * (m_maxScale - m_minScale)) + m_minScale;
 119
 120                         sprintf(buffer, "%f", scale );
 121                         e.AddEPair("modelscale", buffer);
 122                 }
 123
 124                 e.BuildInRadiant( false );
 125         }
 126
 127         if(m_autoLink) {
 128                 DoTrainPathPlot();
 129         }
 130
 131         return SIGNAL_STOP_EMISSION;
 132 }
 133
 134 bool DTreePlanter::FindDropPoint(vec3_t in, vec3_t out) {
 135         DPlane p1;
 136         DPlane p2;
 137
 138         vec3_t vUp =            { 0, 0, 1 };
 139         vec3_t vForward =       { 0, 1, 0 };
 140         vec3_t vLeft =          { 1, 0, 0 };
 141
 142         in[2] = 65535;
 143
 144         VectorCopy(in, p1.points[0]);
 145         VectorCopy(in, p1.points[1]);
 146         VectorCopy(in, p1.points[2]);
 147         VectorMA(p1.points[1], 20, vUp,                 p1.points[1]);
 148         VectorMA(p1.points[1], 20, vLeft,               p1.points[2]);
 149
 150         VectorCopy(in, p2.points[0]);
 151         VectorCopy(in, p2.points[1]);
 152         VectorCopy(in, p2.points[2]);
 153         VectorMA(p1.points[1], 20, vUp,                 p2.points[1]);
 154         VectorMA(p1.points[1], 20, vForward,    p2.points[2]);
 155
 156         p1.Rebuild();
 157         p2.Rebuild();
 158
 159         bool found = false;
 160         vec3_t temp;
 161         vec_t dist;
 162         int cnt = m_world.GetIDMax();
 163         for(int i = 0; i < cnt; i++) {
 164                 DBrush* pBrush = m_world.GetBrushForID( i );
 165
 166                 if(pBrush->IntersectsWith( &p1, &p2, temp )) {
 167                         vec3_t diff;
 168                         vec_t tempdist;
 169                         VectorSubtract(in, temp, diff);
 170                         tempdist = VectorLength( diff );
 171                         if(!found || (tempdist < dist)) {
 172                                 dist = tempdist;
 173                                 VectorCopy( temp, out );
 174                                 found  = true;
 175                         }
 176                 }
 177         }
 178
 179         return found;
 180 }
 181
 182 class TreePlanterDropEntityIfSelected
 183 {
 184   mutable DEntity ent;
 185   DTreePlanter& planter;
 186 public:
 187   TreePlanterDropEntityIfSelected(DTreePlanter& planter) : planter(planter)
 188   {
 189   }
 190   void operator()(scene::Instance& instance) const
 191   {
 192     if(!instance.isSelected())
 193     {
 194       return;
 195     }
 196                 ent.LoadFromEntity(instance.path().top());
 197
 198                 DEPair* pEpair = ent.FindEPairByKey("origin");
 199                 if(!pEpair) {
 200                         return;
 201                 }
 202
 203                 vec3_t vec, out;
 204                 sscanf( pEpair->value.GetBuffer(), "%f %f %f", &vec[0], &vec[1], &vec[2]);
 205
 206                 planter.FindDropPoint( vec, out );
 207
 208                 char buffer[256];
 209                 sprintf( buffer, "%f %f %f", out[0], out[1], out[2] );
 210                 ent.AddEPair( "origin", buffer );
 211                 ent.RemoveFromRadiant();
 212                 ent.BuildInRadiant(false);
 213   }
 214 };
 215
 216 void DTreePlanter::DropEntsToGround( void ) {
 217   Scene_forEachEntity(TreePlanterDropEntityIfSelected(*this));
 218 }
 219
 220 void DTreePlanter::MakeChain( void ) {
 221         char buffer[256];
 222         int i;
 223
 224         for(i = 0; i < m_linkNum; i++) {
 225                 DEntity e("info_train_spline_main");
 226
 227                 sprintf( buffer, "%s_pt%i", m_linkName, i );
 228                 e.AddEPair( "targetname", buffer );
 229
 230                 sprintf( buffer, "0 %i 0", i * 64 );
 231                 e.AddEPair( "origin", buffer );
 232
 233                 if(i != m_linkNum-1) {
 234                         sprintf( buffer, "%s_pt%i", m_linkName, i+1 );
 235                         e.AddEPair( "target", buffer );
 236
 237                         sprintf( buffer, "%s_ctl%i", m_linkName, i );
 238                         e.AddEPair( "control", buffer );
 239                 }
 240
 241                 e.BuildInRadiant( false );
 242         }
 243
 244         for(i = 0; i < m_linkNum-1; i++) {
 245                 DEntity e("info_train_spline_control");
 246
 247                 sprintf( buffer, "%s_ctl%i", m_linkName, i );
 248                 e.AddEPair( "targetname", buffer );
 249
 250                 sprintf( buffer, "0 %i 0", (i * 64) + 32);
 251                 e.AddEPair( "origin", buffer );
 252
 253                 e.BuildInRadiant( false );
 254         }
 255 }
 256
 257 void DTreePlanter::SelectChain( void ) {
 258 /*      char buffer[256];
 259
 260         for(int i = 0; i < m_linkNum; i++) {
 261                 DEntity e("info_train_spline_main");
 262
 263                 sprintf( buffer, "%s_pt%i", m_linkName, i );
 264                 e.AddEPair( "targetname", buffer );
 265
 266                 sprintf( buffer, "0 %i 0", i * 64 );
 267                 e.AddEPair( "origin", buffer );
 268
 269                 if(i != m_linkNum-1) {
 270                         sprintf( buffer, "%s_pt%i", m_linkName, i+1 );
 271                         e.AddEPair( "target", buffer );
 272
 273                         sprintf( buffer, "%s_ctl%i", m_linkName, i );
 274                         e.AddEPair( "control", buffer );
 275                 }
 276
 277                 e.BuildInRadiant( false );
 278         }
 279
 280         for(int i = 0; i < m_linkNum-1; i++) {
 281                 DEntity e("info_train_spline_control");
 282
 283                 sprintf( buffer, "%s_ctl%i", m_linkName, i );
 284                 e.AddEPair( "targetname", buffer );
 285
 286                 sprintf( buffer, "0 %i 0", (i * 64) + 32);
 287                 e.AddEPair( "origin", buffer );
 288
 289                 e.BuildInRadiant( false );
 290         }*/
 291 }