From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_explosion_8cpp_source.html | 728 +++++++++++++++++++++++++++ 1 file changed, 728 insertions(+) create mode 100644 Doc/doxygen/html/_explosion_8cpp_source.html (limited to 'Doc/doxygen/html/_explosion_8cpp_source.html') diff --git a/Doc/doxygen/html/_explosion_8cpp_source.html b/Doc/doxygen/html/_explosion_8cpp_source.html new file mode 100644 index 0000000..7839987 --- /dev/null +++ b/Doc/doxygen/html/_explosion_8cpp_source.html @@ -0,0 +1,728 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/Explosion.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Explosion.cpp
+
+
+Go to the documentation of this file.
1 /* Project Starshatter 4.5
+
2  Destroyer Studios LLC
+
3  Copyright © 1997-2004. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: Stars.exe
+
6  FILE: Explos.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Explosion Sprite animation class
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "Explosion.h"
+
17 #include "QuantumFlash.h"
+
18 #include "Particles.h"
+
19 #include "Ship.h"
+
20 #include "Sim.h"
+
21 #include "CameraDirector.h"
+
22 #include "AudioConfig.h"
+
23 
+
24 #include "Light.h"
+
25 #include "Sprite.h"
+
26 #include "Solid.h"
+
27 #include "Bitmap.h"
+
28 #include "DataLoader.h"
+
29 #include "Game.h"
+
30 #include "Scene.h"
+
31 #include "ParseUtil.h"
+
32 
+
33 // +--------------------------------------------------------------------+
+
34 
+
35 const int MAX_EXPLOSION_TYPES = 32;
+
36 
+
37 static float lifetimes[MAX_EXPLOSION_TYPES];
+
38 static float scales[MAX_EXPLOSION_TYPES];
+
39 static Bitmap* bitmaps[MAX_EXPLOSION_TYPES];
+
40 static Bitmap* particle_bitmaps[MAX_EXPLOSION_TYPES];
+
41 static int part_frames[MAX_EXPLOSION_TYPES];
+
42 static int lengths[MAX_EXPLOSION_TYPES];
+
43 static float light_levels[MAX_EXPLOSION_TYPES];
+
44 static float light_decays[MAX_EXPLOSION_TYPES];
+
45 static Color light_colors[MAX_EXPLOSION_TYPES];
+
46 static int num_parts[MAX_EXPLOSION_TYPES];
+
47 static int part_types[MAX_EXPLOSION_TYPES];
+
48 static float part_speeds[MAX_EXPLOSION_TYPES];
+
49 static float part_drags[MAX_EXPLOSION_TYPES];
+
50 static float part_scales[MAX_EXPLOSION_TYPES];
+
51 static float part_blooms[MAX_EXPLOSION_TYPES];
+
52 static float part_rates[MAX_EXPLOSION_TYPES];
+
53 static float part_decays[MAX_EXPLOSION_TYPES];
+
54 static bool part_trails[MAX_EXPLOSION_TYPES];
+
55 static int part_alphas[MAX_EXPLOSION_TYPES];
+
56 static Sound* sounds[MAX_EXPLOSION_TYPES];
+
57 static bool recycles[MAX_EXPLOSION_TYPES];
+
58 
+
59 // +--------------------------------------------------------------------+
+
60 
+
61 Explosion::Explosion(int t, const Vec3& pos, const Vec3& vel,
+
62 float exp_scale, float part_scale,
+
63 SimRegion* rgn, SimObject* src)
+
64 : SimObject("Explosion", t), type(t), particles(0), source(src)
+
65 {
+
66  Observe(source);
+
67 
+
68  MoveTo(pos);
+
69  velocity = vel;
+
70  drag = 0.3f;
+
71  rep = 0;
+
72  light = 0;
+
73  life = 0;
+
74 
+
75  if (type == QUANTUM_FLASH) {
+
76  life = 1.1;
+
77 
+
78  QuantumFlash* q = new(__FILE__,__LINE__) QuantumFlash();
+
79  rep = q;
+
80 
+
81  light = new(__FILE__,__LINE__) Light(1e9, 0.66f);
+
82  light->SetColor(Color(180, 200, 255));
+
83  }
+
84 
+
85  else if (type >= 0 && type < MAX_EXPLOSION_TYPES) {
+
86  life = lifetimes[type];
+
87 
+
88  if (source) {
+
89  Matrix src_orient = source->Cam().Orientation();
+
90  src_orient.Transpose();
+
91  mount_rel = (pos - source->Location()) * src_orient;
+
92  }
+
93 
+
94  if (lengths[type] > 0) {
+
95  int repeat = (lengths[type] == 1);
+
96  Sprite* s = new(__FILE__,__LINE__) Sprite(bitmaps[type], lengths[type], repeat);
+
97  s->Scale(exp_scale * scales[type]);
+
98  s->SetAngle(PI * rand()/16384.0);
+
99  s->SetLuminous(true);
+
100  rep = s;
+
101  }
+
102 
+
103  if (light_levels[type] > 0) {
+
104  light = new(__FILE__,__LINE__) Light(light_levels[type], light_decays[type]);
+
105  light->SetColor(light_colors[type]);
+
106  }
+
107 
+
108  if (num_parts[type] > 0) {
+
109  particles = new(__FILE__,__LINE__) Particles(particle_bitmaps[type],
+
110  num_parts[type],
+
111  pos,
+
112  Vec3(0.0f, 0.0f, 0.0f),
+
113  part_speeds[type] * part_scale,
+
114  part_drags[type],
+
115  part_scales[type] * part_scale,
+
116  part_blooms[type] * part_scale,
+
117  part_decays[type],
+
118  part_rates[type],
+
119  recycles[type],
+
120  part_trails[type],
+
121  (rgn && rgn->IsAirSpace()),
+
122  part_alphas[type],
+
123  part_frames[type]);
+
124  }
+
125  }
+
126 
+
127  if (rep)
+
128  rep->MoveTo(pos);
+
129 
+
130  if (light)
+
131  light->MoveTo(pos);
+
132 }
+
133 
+
134 // +--------------------------------------------------------------------+
+
135 
+
136 Explosion::~Explosion()
+
137 {
+
138  GRAPHIC_DESTROY(particles);
+
139 }
+
140 
+
141 // +--------------------------------------------------------------------+
+
142 
+
143 bool
+
144 Explosion::Update(SimObject* obj)
+
145 {
+
146  if (obj == source) {
+
147  source = 0;
+
148 
+
149  if (life < 0 || life > 4)
+
150  life = 4;
+
151 
+
152  if (particles)
+
153  particles->StopEmitting();
+
154  }
+
155 
+
156  return SimObserver::Update(obj);
+
157 }
+
158 
+
159 const char*
+
160 Explosion::GetObserverName() const
+
161 {
+
162  static char name[128];
+
163  if (source)
+
164  sprintf_s(name, "Explosion(%s)", source->Name());
+
165  else
+
166  sprintf_s(name, "Explosion");
+
167  return name;
+
168 }
+
169 
+
170 // +--------------------------------------------------------------------+
+
171 
+
172 void
+
173 Explosion::Initialize()
+
174 {
+
175  static int initialized = 0;
+
176  if (initialized) return;
+
177 
+
178  ZeroMemory(lifetimes, sizeof(lifetimes));
+
179  ZeroMemory(scales, sizeof(scales));
+
180  ZeroMemory(bitmaps, sizeof(bitmaps));
+
181  ZeroMemory(particle_bitmaps, sizeof(particle_bitmaps));
+
182  ZeroMemory(lengths, sizeof(lengths));
+
183  ZeroMemory(light_levels, sizeof(light_levels));
+
184  ZeroMemory(light_decays, sizeof(light_decays));
+
185  ZeroMemory(light_colors, sizeof(light_colors));
+
186  ZeroMemory(num_parts, sizeof(num_parts));
+
187  ZeroMemory(part_types, sizeof(part_types));
+
188  ZeroMemory(part_speeds, sizeof(part_speeds));
+
189  ZeroMemory(part_drags, sizeof(part_drags));
+
190  ZeroMemory(part_scales, sizeof(part_scales));
+
191  ZeroMemory(part_blooms, sizeof(part_blooms));
+
192  ZeroMemory(part_decays, sizeof(part_decays));
+
193  ZeroMemory(part_rates, sizeof(part_rates));
+
194  ZeroMemory(part_trails, sizeof(part_trails));
+
195  ZeroMemory(part_alphas, sizeof(part_alphas));
+
196  ZeroMemory(sounds, sizeof(sounds));
+
197  ZeroMemory(recycles, sizeof(recycles));
+
198 
+
199  const char* filename = "Explosions.def";
+
200  Print("Loading Explosion Defs '%s'\n", filename);
+
201 
+
202  // Load Design File:
+
203  DataLoader* loader = DataLoader::GetLoader();
+
204  BYTE* block;
+
205 
+
206  loader->SetDataPath("Explosions/");
+
207  int blocklen = loader->LoadBuffer(filename, block, true);
+
208  Parser parser(new(__FILE__,__LINE__) BlockReader((const char*) block, blocklen));
+
209  Term* term = parser.ParseTerm();
+
210 
+
211  if (!term) {
+
212  Print("ERROR: could not parse '%s'\n", filename);
+
213  exit(-3);
+
214  }
+
215  else {
+
216  TermText* file_type = term->isText();
+
217  if (!file_type || file_type->value() != "EXPLOSION") {
+
218  Print("ERROR: invalid explosion def file '%s'\n", filename);
+
219  exit(-4);
+
220  }
+
221  }
+
222 
+
223  do {
+
224  delete term;
+
225 
+
226  term = parser.ParseTerm();
+
227 
+
228  if (term) {
+
229  TermDef* def = term->isDef();
+
230  if (def) {
+
231  if (def->name()->value() == "explosion") {
+
232 
+
233  if (!def->term() || !def->term()->isStruct()) {
+
234  Print("WARNING: explosion structure missing in '%s'\n", filename);
+
235  }
+
236  else {
+
237  TermStruct* val = def->term()->isStruct();
+
238  int type = -1;
+
239  char type_name[32];
+
240  char bitmap[32];
+
241  char particle_bitmap[32];
+
242  char sound_file[32];
+
243  float lifetime = 0.0f;
+
244  float scale = 1.0f;
+
245  int length = 0;
+
246  float light_level = 0.0f;
+
247  float light_decay = 1.0f;
+
248  Color light_color;
+
249  int num_part = 0;
+
250  int part_type = 0;
+
251  float part_speed = 0.0f;
+
252  float part_drag = 1.0f;
+
253  float part_scale = 1.0f;
+
254  float part_bloom = 0.0f;
+
255  float part_decay = 100.0f;
+
256  float part_rate = 1.0f;
+
257  bool part_trail = true;
+
258  bool continuous = false;
+
259  int part_alpha = 4;
+
260  int part_nframes = 1;
+
261  float sound_min_dist = 1.0f;
+
262  float sound_max_dist = 1.0e5f;
+
263 
+
264  type_name[0] = 0;
+
265  bitmap[0] = 0;
+
266  particle_bitmap[0] = 0;
+
267  sound_file[0] = 0;
+
268 
+
269  for (int i = 0; i < val->elements()->size(); i++) {
+
270  TermDef* pdef = val->elements()->at(i)->isDef();
+
271  if (pdef) {
+
272 
+
273  if (pdef->name()->value() == "type") {
+
274  if (pdef->term()->isText()) {
+
275  GetDefText(type_name, pdef, filename);
+
276 
+
277  const char* names[15] = {
+
278  "SHIELD_FLASH",
+
279  "HULL_FLASH",
+
280  "BEAM_FLASH",
+
281  "SHOT_BLAST",
+
282  "HULL_BURST",
+
283  "HULL_FIRE",
+
284  "PLASMA_LEAK",
+
285  "SMOKE_TRAIL",
+
286  "SMALL_FIRE",
+
287  "SMALL_EXPLOSION",
+
288  "LARGE_EXPLOSION",
+
289  "LARGE_BURST",
+
290  "NUKE_EXPLOSION",
+
291  "QUANTUM_FLASH",
+
292  "HYPER_FLASH"
+
293  };
+
294 
+
295  for (int n = 0; n < 15; n++)
+
296  if (!_stricmp(type_name, names[n]))
+
297  type = n + 1;
+
298  }
+
299 
+
300  else if (pdef->term()->isNumber()) {
+
301  GetDefNumber(type, pdef, filename);
+
302 
+
303  if (type < 0 || type >= MAX_EXPLOSION_TYPES) {
+
304  ::Print("Warning - invalid explosion type %d ignored\n", type);
+
305  }
+
306  }
+
307 
+
308  else {
+
309  ::Print("Warning - weird explosion type:\n");
+
310  pdef->print();
+
311  }
+
312  }
+
313 
+
314  else if (pdef->name()->value() == "image" ||
+
315  pdef->name()->value() == "bitmap")
+
316  GetDefText(bitmap, pdef, filename);
+
317 
+
318  else if (pdef->name()->value() == "particles" ||
+
319  pdef->name()->value() == "particle_bitmap")
+
320  GetDefText(particle_bitmap, pdef, filename);
+
321 
+
322  else if (pdef->name()->value() == "sound")
+
323  GetDefText(sound_file, pdef, filename);
+
324 
+
325  else if (pdef->name()->value() == "lifetime")
+
326  GetDefNumber(lifetime, pdef, filename);
+
327 
+
328  else if (pdef->name()->value() == "scale")
+
329  GetDefNumber(scale, pdef, filename);
+
330 
+
331  else if (pdef->name()->value() == "length")
+
332  GetDefNumber(length, pdef, filename);
+
333 
+
334  else if (pdef->name()->value() == "light_level")
+
335  GetDefNumber(light_level, pdef, filename);
+
336 
+
337  else if (pdef->name()->value() == "light_decay")
+
338  GetDefNumber(light_decay, pdef, filename);
+
339 
+
340  else if (pdef->name()->value() == "light_color")
+
341  GetDefColor(light_color, pdef, filename);
+
342 
+
343  else if (pdef->name()->value() == "num_parts")
+
344  GetDefNumber(num_part, pdef, filename);
+
345 
+
346  else if (pdef->name()->value() == "part_frames")
+
347  GetDefNumber(part_nframes, pdef, filename);
+
348 
+
349  else if (pdef->name()->value() == "part_type")
+
350  GetDefNumber(part_type, pdef, filename);
+
351 
+
352  else if (pdef->name()->value() == "part_speed")
+
353  GetDefNumber(part_speed, pdef, filename);
+
354 
+
355  else if (pdef->name()->value() == "part_drag")
+
356  GetDefNumber(part_drag, pdef, filename);
+
357 
+
358  else if (pdef->name()->value() == "part_scale")
+
359  GetDefNumber(part_scale, pdef, filename);
+
360 
+
361  else if (pdef->name()->value() == "part_bloom")
+
362  GetDefNumber(part_bloom, pdef, filename);
+
363 
+
364  else if (pdef->name()->value() == "part_decay")
+
365  GetDefNumber(part_decay, pdef, filename);
+
366 
+
367  else if (pdef->name()->value() == "part_rate")
+
368  GetDefNumber(part_rate, pdef, filename);
+
369 
+
370  else if (pdef->name()->value() == "part_trail")
+
371  GetDefBool(part_trail, pdef, filename);
+
372 
+
373  else if (pdef->name()->value() == "part_alpha")
+
374  GetDefNumber(part_alpha, pdef, filename);
+
375 
+
376  else if (pdef->name()->value() == "continuous")
+
377  GetDefBool(continuous, pdef, filename);
+
378 
+
379  else if (pdef->name()->value() == "sound_min_dist")
+
380  GetDefNumber(sound_min_dist, pdef, filename);
+
381 
+
382  else if (pdef->name()->value() == "sound_max_dist")
+
383  GetDefNumber(sound_max_dist, pdef, filename);
+
384 
+
385  else {
+
386  Print("WARNING: parameter '%s' ignored in '%s'\n",
+
387  pdef->name()->value().data(), filename);
+
388  }
+
389  }
+
390  else {
+
391  Print("WARNING: term ignored in '%s'\n", filename);
+
392  val->elements()->at(i)->print();
+
393  }
+
394  }
+
395 
+
396  if (type >= 0 && type < MAX_EXPLOSION_TYPES) {
+
397  if (part_alpha > 2)
+
398  part_alpha = 4;
+
399 
+
400  lengths[type] = length;
+
401  lifetimes[type] = lifetime;
+
402  scales[type] = scale;
+
403  light_levels[type] = light_level;
+
404  light_decays[type] = light_decay;
+
405  light_colors[type] = light_color;
+
406  num_parts[type] = num_part;
+
407  part_types[type] = part_type;
+
408  part_speeds[type] = part_speed;
+
409  part_drags[type] = part_drag;
+
410  part_scales[type] = part_scale;
+
411  part_blooms[type] = part_bloom;
+
412  part_frames[type] = part_nframes;
+
413  part_decays[type] = part_decay;
+
414  part_rates[type] = part_rate;
+
415  part_trails[type] = part_trail;
+
416  part_alphas[type] = part_alpha;
+
417  recycles[type] = continuous;
+
418 
+
419  if (length > 0) {
+
420  bitmaps[type] = new(__FILE__,__LINE__) Bitmap[length];
+
421 
+
422  if (length > 1) {
+
423  for (int n = 0; n < length; n++) {
+
424  char img_name[64];
+
425  sprintf_s(img_name, "%s%02d.pcx", bitmap, n);
+
426  loader->LoadBitmap(img_name, bitmaps[type][n], Bitmap::BMP_TRANSLUCENT);
+
427  }
+
428  }
+
429 
+
430  else {
+
431  loader->LoadBitmap(bitmap, bitmaps[type][0], Bitmap::BMP_TRANSLUCENT);
+
432  }
+
433  }
+
434 
+
435  if (particle_bitmap[0]) {
+
436  particle_bitmaps[type] = new(__FILE__,__LINE__) Bitmap[part_nframes];
+
437 
+
438  if (part_nframes > 1) {
+
439  for (int i = 0; i < part_nframes; i++) {
+
440  char fname[64];
+
441  sprintf_s(fname, "%s%02d.pcx", particle_bitmap, i);
+
442  loader->LoadBitmap(fname, particle_bitmaps[type][i], Bitmap::BMP_TRANSLUCENT);
+
443  particle_bitmaps[type][i].MakeTexture();
+
444  }
+
445  }
+
446 
+
447  else {
+
448  loader->LoadBitmap(particle_bitmap, particle_bitmaps[type][0], Bitmap::BMP_TRANSLUCENT);
+
449  particle_bitmaps[type][0].MakeTexture();
+
450  }
+
451  }
+
452 
+
453  if (sound_file[0]) {
+
454  loader->SetDataPath("Sounds/");
+
455  loader->LoadSound(sound_file, sounds[type], Sound::LOCALIZED | Sound::LOC_3D);
+
456  loader->SetDataPath("Explosions/");
+
457 
+
458  if (sounds[type]) {
+
459  sounds[type]->SetMinDistance(sound_min_dist);
+
460  sounds[type]->SetMaxDistance(sound_max_dist);
+
461  }
+
462  }
+
463  }
+
464  }
+
465  }
+
466 
+
467  else
+
468  Print("WARNING: unknown definition '%s' in '%s'\n",
+
469  def->name()->value().data(), filename);
+
470  }
+
471  else {
+
472  Print("WARNING: term ignored in '%s'\n", filename);
+
473  term->print();
+
474  }
+
475  }
+
476  }
+
477  while (term);
+
478 
+
479  loader->ReleaseBuffer(block);
+
480  loader->SetDataPath(0);
+
481  initialized = 1;
+
482 }
+
483 
+
484 // +--------------------------------------------------------------------+
+
485 
+
486 void
+
487 Explosion::Close()
+
488 {
+
489  for (int t = 0; t < MAX_EXPLOSION_TYPES; t++) {
+
490  if (lengths[t] && bitmaps[t]) {
+
491  for (int i = 0; i < lengths[t]; i++)
+
492  bitmaps[t][i].ClearImage();
+
493  delete [] bitmaps[t];
+
494  }
+
495 
+
496  if (particle_bitmaps[t]) {
+
497  for (int i = 0; i < part_frames[t]; i++)
+
498  particle_bitmaps[t][i].ClearImage();
+
499  delete [] particle_bitmaps[t];
+
500  }
+
501 
+
502  delete sounds[t];
+
503  }
+
504 }
+
505 
+
506 // +--------------------------------------------------------------------+
+
507 
+
508 void
+
509 Explosion::ExecFrame(double seconds)
+
510 {
+
511  if (source) {
+
512  const Matrix& orientation = source->Cam().Orientation();
+
513  MoveTo((mount_rel * orientation) + source->Location());
+
514 
+
515  if (rep) rep->Show();
+
516 
+
517  if (particles) particles->Show();
+
518 
+
519  if (source == Sim::GetSim()->GetPlayerShip()) {
+
520  Ship* ship = (Ship*) source;
+
521  if (CameraDirector::GetCameraMode() == CameraDirector::MODE_COCKPIT &&
+
522  !ship->IsDying()) {
+
523  if (rep) rep->Hide();
+
524  if (particles) particles->Hide();
+
525  }
+
526  }
+
527  }
+
528 
+
529  life -= seconds;
+
530 
+
531  if (rep) {
+
532  rep->MoveTo(Location());
+
533 
+
534  if (rep->Life() == 0) {
+
535  rep = 0; // about to be GC'd
+
536  }
+
537 
+
538  else if (rep->IsSprite()) {
+
539  Sprite* s = (Sprite*) rep;
+
540  s->SetAngle(s->Angle() + seconds * 0.5);
+
541  }
+
542 
+
543  else if (type == QUANTUM_FLASH) {
+
544  QuantumFlash* q = (QuantumFlash*) rep;
+
545  q->SetShade(q->Shade() - seconds);
+
546  }
+
547  }
+
548 
+
549  if (light) {
+
550  light->Update();
+
551 
+
552  if (light->Life() == 0)
+
553  light = 0; // about to be GC'd
+
554  }
+
555 
+
556  if (particles) {
+
557  particles->MoveTo(Location());
+
558  particles->ExecFrame(seconds);
+
559  }
+
560 
+
561  if (source && source->Life() == 0)
+
562  life = 0;
+
563 }
+
564 
+
565 // +--------------------------------------------------------------------+
+
566 
+
567 void
+
568 Explosion::Activate(Scene& scene)
+
569 {
+
570  bool filter = false;
+
571 
+
572  CameraDirector* cam_dir = CameraDirector::GetInstance();
+
573  if (cam_dir && cam_dir->GetCamera()) {
+
574  if (Point(cam_dir->GetCamera()->Pos() - Location()).length() < 100)
+
575  filter = true;
+
576  }
+
577 
+
578  if (rep && !filter)
+
579  scene.AddGraphic(rep);
+
580 
+
581  if (light)
+
582  scene.AddLight(light);
+
583 
+
584  if (particles && !filter)
+
585  scene.AddGraphic(particles);
+
586 
+
587  if (sounds[obj_type]) {
+
588  Sound* sound = sounds[obj_type]->Duplicate();
+
589 
+
590  // fire and forget:
+
591  if (sound) {
+
592  sound->SetLocation(Location());
+
593  sound->SetVolume(AudioConfig::EfxVolume());
+
594  sound->Play();
+
595  }
+
596  }
+
597 
+
598  active = true;
+
599 }
+
600 
+
601 void
+
602 Explosion::Deactivate(Scene& scene)
+
603 {
+
604  SimObject::Deactivate(scene);
+
605 
+
606  if (particles)
+
607  scene.DelGraphic(particles);
+
608 }
+
609 
+
610 // +--------------------------------------------------------------------+
+
611 
+
+
+ + + + -- cgit v1.1