src/vista/Filtros.pas

   1 {** Se implementan varios filtro en diferentes direcciones.<br>\r
   2     <i>Cambios:</i>\r
   3     <PRE>\r
   4     09/12/00: Se agrega la clase cFiltroMapa.\r
   5     </PRE>}\r
   6 unit Filtros;\r
   7 \r
   8 interface\r
   9 \r
  10 uses\r
  11   Tipos,\r
  12   Vectores,\r
  13   ObjetoVolador,\r
  14   Sysutils,\r
  15   Filtro;\r
  16 \r
  17 type\r
  18 \r
  19   {** Implementa un filtro que "ve" hacia adelante.}\r
  20   cFiltroFrontal = class( cFiltro )\r
  21     protected\r
  22       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  23       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  24   end;\r
  25 \r
  26   {** Implementa un filtro que "ve" hacia la izquierda.}\r
  27   cFiltroLatIzq = class( cFiltro )\r
  28     protected\r
  29       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  30       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  31   end;\r
  32 \r
  33   {** Implementa un filtro que "ve" hacia la derecha.}\r
  34   cFiltroLatDer = class( cFiltro )\r
  35     protected\r
  36       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  37       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  38   end;\r
  39 \r
  40   {** Implementa un filtro que "ve" hacia atrás.}\r
  41   cFiltroTrasero = class( cFiltro )\r
  42     protected\r
  43       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  44       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  45   end;\r
  46 \r
  47   {** Implementa un filtro que "ve" hacia arriba.}\r
  48   cFiltroArriba = class( cFiltro )\r
  49     protected\r
  50       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  51       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  52   end;\r
  53 \r
  54   {** Implementa un filtro que "ve" hacia abajo.}\r
  55   cFiltroAbajo = class( cFiltro )\r
  56     protected\r
  57       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  58       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  59   end;\r
  60 \r
  61   {** Implementa un filtro que "ve" hacia abajo pero desde arriba a una cierta distancia\r
  62       del observador. Es como si observara al observador mismo.}\r
  63   cFiltroMapa = class( cFiltro )\r
  64     protected\r
  65       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  66       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  67   end;\r
  68 \r
  69   {** Implementa un filtro que "ve" hacia adelante y que además sólo puede\r
  70       ver objetos del tipo cNave y cMeteorito.}\r
  71   cFiltroLock = class( cFiltroFrontal )\r
  72     protected\r
  73       {** Verifica que un objeto volador pueda ser visto por la cámara}\r
  74       function mVisible( ov: cObjetoVolador ): boolean; override;\r
  75   end;\r
  76 \r
  77 implementation\r
  78 \r
  79 uses\r
  80   Nave,\r
  81   Meteorito;\r
  82 \r
  83 { cFiltroFrontal }\r
  84 \r
  85 {** Verifica que un objeto volador pueda ser visto por la cámara\r
  86     @param  ov Objeto volador que se quiere verificar si es visto por la cámara.\r
  87     @return    <i>True</i> si lo ve, <i>False</i> si no.}\r
  88 function cFiltroFrontal.mVisible(ov: cObjetoVolador): boolean;\r
  89 var\r
  90   posRel,             // vector posicion del objeto volador relativo a la camara\r
  91   posCam,             // Posision del cameraman\r
  92   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
  93   dist:    tLongitud; // Distancia entre la camara y el objeto\r
  94   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
  95 begin\r
  96   result := false;\r
  97   try // Probamos que el cameraman no este destruido\r
  98     dist := mGetObservador.mGetDistancia( ov );\r
  99   except // Si esta destruido cae en una excepcion\r
 100     on e: EAccessViolation do\r
 101       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 102   end;\r
 103   if ( dist > mGetRadioMinimo ) and\r
 104      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 105     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 106     posRel := ov.mGetPosicion;\r
 107     posCam := mGetObservador.mGetPosicion;\r
 108     posRel.mRestar( posCam );\r
 109     dirCam := mGetObservador.mGetI;\r
 110     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 111     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 112     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 113     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 114       result := true;\r
 115     posRel.free;\r
 116     posCam.free;\r
 117     dirCam.free;\r
 118   end;\r
 119 end;\r
 120 \r
 121 { cFiltroLatIzq }\r
 122 \r
 123 {** Verifica que un objeto volador pueda ser visto por la cámara\r
 124     @param  ov Objeto volador que se quiere verificar si es visto por la cámara.\r
 125     @return    <i>True</i> si lo ve, <i>False</i> si no.}\r
 126 function cFiltroLatIzq.mVisible(ov: cObjetoVolador): boolean;\r
 127 var\r
 128   posRel,             // vector posicion del objeto volador relativo a la camara\r
 129   posCam,             // Posision del cameraman\r
 130   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 131   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 132   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 133 begin\r
 134   result := false;\r
 135   try // Probamos que el cameraman no este destruido\r
 136     dist := mGetObservador.mGetDistancia( ov );\r
 137   except // Si esta destruido cae en una excepcion\r
 138     on e: EAccessViolation do\r
 139       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 140   end;\r
 141   if ( dist > mGetRadioMinimo ) and\r
 142      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 143     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 144     posRel := ov.mGetPosicion;\r
 145     posCam := mGetObservador.mGetPosicion;\r
 146     posRel.mRestar( posCam );\r
 147     dirCam := mGetObservador.mGetJ;\r
 148     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 149     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 150     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 151     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 152       result := true;\r
 153     posRel.free;\r
 154     posCam.free;\r
 155     dirCam.free;\r
 156   end;\r
 157 end;\r
 158 \r
 159 { cFiltroLatDer }\r
 160 \r
 161 function cFiltroLatDer.mVisible(ov: cObjetoVolador): boolean;\r
 162 var\r
 163   posRel,             // vector posicion del objeto volador relativo a la camara\r
 164   posCam,             // Posision del cameraman\r
 165   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 166   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 167   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 168 begin\r
 169   result := false;\r
 170   try // Probamos que el cameraman no este destruido\r
 171     dist := mGetObservador.mGetDistancia( ov );\r
 172   except // Si esta destruido cae en una excepcion\r
 173     on e: EAccessViolation do\r
 174       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 175   end;\r
 176   if ( dist > mGetRadioMinimo ) and\r
 177      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 178     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 179     posRel := ov.mGetPosicion;\r
 180     posCam := mGetObservador.mGetPosicion;\r
 181     posRel.mRestar( posCam );\r
 182     dirCam := mGetObservador.mGetJ.mMultiplicar(-1);\r
 183     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 184     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 185     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 186     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 187       result := true;\r
 188     posRel.free;\r
 189     posCam.free;\r
 190     dirCam.free;\r
 191   end;\r
 192 end;\r
 193 \r
 194 { cFiltroTrasero }\r
 195 \r
 196 function cFiltroTrasero.mVisible(ov: cObjetoVolador): boolean;\r
 197 var\r
 198   posRel,             // vector posicion del objeto volador relativo a la camara\r
 199   posCam,             // Posision del cameraman\r
 200   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 201   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 202   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 203 begin\r
 204   result := false;\r
 205   try // Probamos que el cameraman no este destruido\r
 206     dist := mGetObservador.mGetDistancia( ov );\r
 207   except // Si esta destruido cae en una excepcion\r
 208     on e: EAccessViolation do\r
 209       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 210   end;\r
 211   if ( dist > mGetRadioMinimo ) and\r
 212      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 213     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 214     posRel := ov.mGetPosicion;\r
 215     posCam := mGetObservador.mGetPosicion;\r
 216     posRel.mRestar( posCam );\r
 217     dirCam := mGetObservador.mGetI.mMultiplicar(-1);\r
 218     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 219     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 220     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 221     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 222       result := true;\r
 223     posRel.free;\r
 224     posCam.free;\r
 225     dirCam.free;\r
 226   end;\r
 227 end;\r
 228 \r
 229 { cFiltroArriba }\r
 230 \r
 231 function cFiltroArriba.mVisible(ov: cObjetoVolador): boolean;\r
 232 var\r
 233   posRel,             // vector posicion del objeto volador relativo a la camara\r
 234   posCam,             // Posision del cameraman\r
 235   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 236   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 237   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 238 begin\r
 239   result := false;\r
 240   try // Probamos que el cameraman no este destruido\r
 241     dist := mGetObservador.mGetDistancia( ov );\r
 242   except // Si esta destruido cae en una excepcion\r
 243     on e: EAccessViolation do\r
 244       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 245   end;\r
 246   if ( dist > mGetRadioMinimo ) and\r
 247      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 248     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 249     posRel := ov.mGetPosicion;\r
 250     posCam := mGetObservador.mGetPosicion;\r
 251     posRel.mRestar( posCam );\r
 252     dirCam := mGetObservador.mGetK;\r
 253     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 254     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 255     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 256     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 257       result := true;\r
 258     posRel.free;\r
 259     posCam.free;\r
 260     dirCam.free;\r
 261   end;\r
 262 end;\r
 263 \r
 264 { cFiltroAbajo }\r
 265 \r
 266 function cFiltroAbajo.mVisible(ov: cObjetoVolador): boolean;\r
 267 var\r
 268   posRel,             // vector posicion del objeto volador relativo a la camara\r
 269   posCam,             // Posision del cameraman\r
 270   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 271   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 272   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 273 begin\r
 274   result := false;\r
 275   try // Probamos que el cameraman no este destruido\r
 276     dist := mGetObservador.mGetDistancia( ov );\r
 277   except // Si esta destruido cae en una excepcion\r
 278     on e: EAccessViolation do\r
 279       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 280   end;\r
 281   if ( dist > mGetRadioMinimo ) and\r
 282      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 283     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 284     posRel := ov.mGetPosicion;\r
 285     posCam := mGetObservador.mGetPosicion;\r
 286     posRel.mRestar( posCam );\r
 287     dirCam := mGetObservador.mGetK.mMultiplicar(-1);\r
 288     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 289     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 290     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 291     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 292       result := true;\r
 293     posRel.free;\r
 294     posCam.free;\r
 295     dirCam.free;\r
 296   end;\r
 297 end;\r
 298 \r
 299 { cFiltroMapa }\r
 300 \r
 301 function cFiltroMapa.mVisible(ov: cObjetoVolador): boolean;\r
 302 var\r
 303   desplazamiento,     // desplazamiento del filtro respecto del observador\r
 304   posTmp,             // Vector posicion temporal\r
 305   posRel,             // vector posicion del objeto volador relativo a la camara\r
 306   posCam,             // Posision del cameraman\r
 307   dirCam:  cVector;   // vector con la direccion en la que apunta la camara\r
 308   dist:    tLongitud; // Distancia entre la camara y el objeto\r
 309   cosAlfa: tAngulo;   // Coseno del angulo que forman la dir de la camara y la pos del objeto\r
 310 begin\r
 311   result := false;\r
 312   try // Probamos que el cameraman no este destruido\r
 313     desplazamiento := mGetObservador.mGetk.mSetModulo( 3000 ); // Esta 3000 metros alejado del observador\r
 314   except // Si esta destruido cae en una excepcion\r
 315     on e: EAccessViolation do\r
 316       raise EObservadorDestruido.create; // Creamos una nueva excepcion especial\r
 317   end;\r
 318   posCam := mGetObservador.mGetPosicion.mSumar( desplazamiento );\r
 319   desplazamiento.free;\r
 320   posTmp := ov.mGetPosicion;\r
 321   dist := posCam.mGetDistancia( posTmp );\r
 322   posTmp.free;\r
 323   if ( dist > mGetRadioMinimo ) and\r
 324      ( dist < mGetRadioMaximo ) then begin // Esta dentro de la distancia minima y maxima\r
 325     // posRel es el vector posicion del objeto volador relativo a la camara: posRel = posOV - posCam\r
 326     posRel := ov.mGetPosicion;\r
 327     posRel.mRestar( posCam );\r
 328     dirCam := mGetObservador.mGetK.mMultiplicar(-1);\r
 329     // Calcula el angulo entre las 2 posiciones ( A . B / |A| . |B| )\r
 330     cosAlfa := posRel.mMultiplicarEsc( dirCam ) / ( posRel.mGetModulo * dirCam.mGetModulo);\r
 331     // Ahora se comparan los cosenos, ya que es una funcion decreciente entre 0 y PI\r
 332     if cosAlfa > mGetCosApertura then // Esta dentro del angulo de vision\r
 333       result := true;\r
 334     posRel.free;\r
 335     dirCam.free;\r
 336   end;\r
 337   posCam.free;\r
 338 end;\r
 339 \r
 340 { cFiltroLock }\r
 341 \r
 342 {** Verifica que un objeto volador pueda ser visto por la cámara}\r
 343 function cFiltroLock.mVisible(ov: cObjetoVolador): boolean;\r
 344 begin\r
 345   result := false;\r
 346   if (ov is cNave) or (ov is cMeteorito) then\r
 347     result := inherited mVisible( ov );\r
 348 end;\r
 349 \r
 350 end.\r