From 3c487c5cd69c53d6fea948643c0a76df03516605 Mon Sep 17 00:00:00 2001 From: Aki Date: Fri, 1 Apr 2022 21:23:39 +0200 Subject: Moved Stars45 to StarsEx --- StarsEx/Explosion.cpp | 609 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 609 insertions(+) create mode 100644 StarsEx/Explosion.cpp (limited to 'StarsEx/Explosion.cpp') diff --git a/StarsEx/Explosion.cpp b/StarsEx/Explosion.cpp new file mode 100644 index 0000000..9a47b0b --- /dev/null +++ b/StarsEx/Explosion.cpp @@ -0,0 +1,609 @@ +/* Starshatter: The Open Source Project + Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors + Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors + Copyright (c) 1997-2006, Destroyer Studios LLC. + + AUTHOR: John DiCamillo + + + OVERVIEW + ======== + Explosion Sprite animation class +*/ + +#include "Explosion.h" +#include "QuantumFlash.h" +#include "Particles.h" +#include "Ship.h" +#include "Sim.h" +#include "CameraDirector.h" +#include "AudioConfig.h" + +#include "Light.h" +#include "Sprite.h" +#include "Solid.h" +#include "Bitmap.h" +#include "DataLoader.h" +#include "Game.h" +#include "Scene.h" +#include "ParseUtil.h" + +// +--------------------------------------------------------------------+ + +const int MAX_EXPLOSION_TYPES = 32; + +static float lifetimes[MAX_EXPLOSION_TYPES]; +static float scales[MAX_EXPLOSION_TYPES]; +static Bitmap* bitmaps[MAX_EXPLOSION_TYPES]; +static Bitmap* particle_bitmaps[MAX_EXPLOSION_TYPES]; +static int part_frames[MAX_EXPLOSION_TYPES]; +static int lengths[MAX_EXPLOSION_TYPES]; +static float light_levels[MAX_EXPLOSION_TYPES]; +static float light_decays[MAX_EXPLOSION_TYPES]; +static Color light_colors[MAX_EXPLOSION_TYPES]; +static int num_parts[MAX_EXPLOSION_TYPES]; +static int part_types[MAX_EXPLOSION_TYPES]; +static float part_speeds[MAX_EXPLOSION_TYPES]; +static float part_drags[MAX_EXPLOSION_TYPES]; +static float part_scales[MAX_EXPLOSION_TYPES]; +static float part_blooms[MAX_EXPLOSION_TYPES]; +static float part_rates[MAX_EXPLOSION_TYPES]; +static float part_decays[MAX_EXPLOSION_TYPES]; +static bool part_trails[MAX_EXPLOSION_TYPES]; +static int part_alphas[MAX_EXPLOSION_TYPES]; +static Sound* sounds[MAX_EXPLOSION_TYPES]; +static bool recycles[MAX_EXPLOSION_TYPES]; + +// +--------------------------------------------------------------------+ + +Explosion::Explosion(int t, const Vec3& pos, const Vec3& vel, +float exp_scale, float part_scale, +SimRegion* rgn, SimObject* src) +: SimObject("Explosion", t), type(t), particles(0), source(src) +{ + Observe(source); + + MoveTo(pos); + velocity = vel; + drag = 0.3f; + rep = 0; + light = 0; + life = 0; + + if (type == QUANTUM_FLASH) { + life = 1.1; + + QuantumFlash* q = new QuantumFlash(); + rep = q; + + light = new Light(1e9, 0.66f); + light->SetColor(Color(180, 200, 255)); + } + + else if (type >= 0 && type < MAX_EXPLOSION_TYPES) { + life = lifetimes[type]; + + if (source) { + Matrix src_orient = source->Cam().Orientation(); + src_orient.Transpose(); + mount_rel = (pos - source->Location()) * src_orient; + } + + if (lengths[type] > 0) { + int repeat = (lengths[type] == 1); + Sprite* s = new Sprite(bitmaps[type], lengths[type], repeat); + s->Scale(exp_scale * scales[type]); + s->SetAngle(PI * rand()/16384.0); + s->SetLuminous(true); + rep = s; + } + + if (light_levels[type] > 0) { + light = new Light(light_levels[type], light_decays[type]); + light->SetColor(light_colors[type]); + } + + if (num_parts[type] > 0) { + particles = new Particles(particle_bitmaps[type], + num_parts[type], + pos, + Vec3(0.0f, 0.0f, 0.0f), + part_speeds[type] * part_scale, + part_drags[type], + part_scales[type] * part_scale, + part_blooms[type] * part_scale, + part_decays[type], + part_rates[type], + recycles[type], + part_trails[type], + (rgn && rgn->IsAirSpace()), + part_alphas[type], + part_frames[type]); + } + } + + if (rep) + rep->MoveTo(pos); + + if (light) + light->MoveTo(pos); +} + +// +--------------------------------------------------------------------+ + +Explosion::~Explosion() +{ + GRAPHIC_DESTROY(particles); +} + +// +--------------------------------------------------------------------+ + +bool +Explosion::Update(SimObject* obj) +{ + if (obj == source) { + source = 0; + + if (life < 0 || life > 4) + life = 4; + + if (particles) + particles->StopEmitting(); + } + + return SimObserver::Update(obj); +} + +const char* +Explosion::GetObserverName() const +{ + static char name[128]; + if (source) + sprintf_s(name, "Explosion(%s)", source->Name()); + else + sprintf_s(name, "Explosion"); + return name; +} + +// +--------------------------------------------------------------------+ + +void +Explosion::Initialize() +{ + static int initialized = 0; + if (initialized) return; + + ZeroMemory(lifetimes, sizeof(lifetimes)); + ZeroMemory(scales, sizeof(scales)); + ZeroMemory(bitmaps, sizeof(bitmaps)); + ZeroMemory(particle_bitmaps, sizeof(particle_bitmaps)); + ZeroMemory(lengths, sizeof(lengths)); + ZeroMemory(light_levels, sizeof(light_levels)); + ZeroMemory(light_decays, sizeof(light_decays)); + ZeroMemory(light_colors, sizeof(light_colors)); + ZeroMemory(num_parts, sizeof(num_parts)); + ZeroMemory(part_types, sizeof(part_types)); + ZeroMemory(part_speeds, sizeof(part_speeds)); + ZeroMemory(part_drags, sizeof(part_drags)); + ZeroMemory(part_scales, sizeof(part_scales)); + ZeroMemory(part_blooms, sizeof(part_blooms)); + ZeroMemory(part_decays, sizeof(part_decays)); + ZeroMemory(part_rates, sizeof(part_rates)); + ZeroMemory(part_trails, sizeof(part_trails)); + ZeroMemory(part_alphas, sizeof(part_alphas)); + ZeroMemory(sounds, sizeof(sounds)); + ZeroMemory(recycles, sizeof(recycles)); + + const char* filename = "Explosions.def"; + Print("Loading Explosion Defs '%s'\n", filename); + + // Load Design File: + DataLoader* loader = DataLoader::GetLoader(); + BYTE* block; + + loader->SetDataPath("Explosions/"); + int blocklen = loader->LoadBuffer(filename, block, true); + Parser parser(new BlockReader((const char*) block, blocklen)); + Term* term = parser.ParseTerm(); + + if (!term) { + Print("ERROR: could not parse '%s'\n", filename); + exit(-3); + } + else { + TermText* file_type = term->isText(); + if (!file_type || file_type->value() != "EXPLOSION") { + Print("ERROR: invalid explosion def file '%s'\n", filename); + exit(-4); + } + } + + do { + delete term; + + term = parser.ParseTerm(); + + if (term) { + TermDef* def = term->isDef(); + if (def) { + if (def->name()->value() == "explosion") { + + if (!def->term() || !def->term()->isStruct()) { + Print("WARNING: explosion structure missing in '%s'\n", filename); + } + else { + TermStruct* val = def->term()->isStruct(); + int type = -1; + char type_name[32]; + char bitmap[32]; + char particle_bitmap[32]; + char sound_file[32]; + float lifetime = 0.0f; + float scale = 1.0f; + int length = 0; + float light_level = 0.0f; + float light_decay = 1.0f; + Color light_color; + int num_part = 0; + int part_type = 0; + float part_speed = 0.0f; + float part_drag = 1.0f; + float part_scale = 1.0f; + float part_bloom = 0.0f; + float part_decay = 100.0f; + float part_rate = 1.0f; + bool part_trail = true; + bool continuous = false; + int part_alpha = 4; + int part_nframes = 1; + float sound_min_dist = 1.0f; + float sound_max_dist = 1.0e5f; + + type_name[0] = 0; + bitmap[0] = 0; + particle_bitmap[0] = 0; + sound_file[0] = 0; + + for (int i = 0; i < val->elements()->size(); i++) { + TermDef* pdef = val->elements()->at(i)->isDef(); + if (pdef) { + + if (pdef->name()->value() == "type") { + if (pdef->term()->isText()) { + GetDefText(type_name, pdef, filename); + + const char* names[15] = { + "SHIELD_FLASH", + "HULL_FLASH", + "BEAM_FLASH", + "SHOT_BLAST", + "HULL_BURST", + "HULL_FIRE", + "PLASMA_LEAK", + "SMOKE_TRAIL", + "SMALL_FIRE", + "SMALL_EXPLOSION", + "LARGE_EXPLOSION", + "LARGE_BURST", + "NUKE_EXPLOSION", + "QUANTUM_FLASH", + "HYPER_FLASH" + }; + + for (int n = 0; n < 15; n++) + if (!_stricmp(type_name, names[n])) + type = n + 1; + } + + else if (pdef->term()->isNumber()) { + GetDefNumber(type, pdef, filename); + + if (type < 0 || type >= MAX_EXPLOSION_TYPES) { + ::Print("Warning - invalid explosion type %d ignored\n", type); + } + } + + else { + ::Print("Warning - weird explosion type:\n"); + pdef->print(); + } + } + + else if (pdef->name()->value() == "image" || + pdef->name()->value() == "bitmap") + GetDefText(bitmap, pdef, filename); + + else if (pdef->name()->value() == "particles" || + pdef->name()->value() == "particle_bitmap") + GetDefText(particle_bitmap, pdef, filename); + + else if (pdef->name()->value() == "sound") + GetDefText(sound_file, pdef, filename); + + else if (pdef->name()->value() == "lifetime") + GetDefNumber(lifetime, pdef, filename); + + else if (pdef->name()->value() == "scale") + GetDefNumber(scale, pdef, filename); + + else if (pdef->name()->value() == "length") + GetDefNumber(length, pdef, filename); + + else if (pdef->name()->value() == "light_level") + GetDefNumber(light_level, pdef, filename); + + else if (pdef->name()->value() == "light_decay") + GetDefNumber(light_decay, pdef, filename); + + else if (pdef->name()->value() == "light_color") + GetDefColor(light_color, pdef, filename); + + else if (pdef->name()->value() == "num_parts") + GetDefNumber(num_part, pdef, filename); + + else if (pdef->name()->value() == "part_frames") + GetDefNumber(part_nframes, pdef, filename); + + else if (pdef->name()->value() == "part_type") + GetDefNumber(part_type, pdef, filename); + + else if (pdef->name()->value() == "part_speed") + GetDefNumber(part_speed, pdef, filename); + + else if (pdef->name()->value() == "part_drag") + GetDefNumber(part_drag, pdef, filename); + + else if (pdef->name()->value() == "part_scale") + GetDefNumber(part_scale, pdef, filename); + + else if (pdef->name()->value() == "part_bloom") + GetDefNumber(part_bloom, pdef, filename); + + else if (pdef->name()->value() == "part_decay") + GetDefNumber(part_decay, pdef, filename); + + else if (pdef->name()->value() == "part_rate") + GetDefNumber(part_rate, pdef, filename); + + else if (pdef->name()->value() == "part_trail") + GetDefBool(part_trail, pdef, filename); + + else if (pdef->name()->value() == "part_alpha") + GetDefNumber(part_alpha, pdef, filename); + + else if (pdef->name()->value() == "continuous") + GetDefBool(continuous, pdef, filename); + + else if (pdef->name()->value() == "sound_min_dist") + GetDefNumber(sound_min_dist, pdef, filename); + + else if (pdef->name()->value() == "sound_max_dist") + GetDefNumber(sound_max_dist, pdef, filename); + + else { + Print("WARNING: parameter '%s' ignored in '%s'\n", + pdef->name()->value().data(), filename); + } + } + else { + Print("WARNING: term ignored in '%s'\n", filename); + val->elements()->at(i)->print(); + } + } + + if (type >= 0 && type < MAX_EXPLOSION_TYPES) { + if (part_alpha > 2) + part_alpha = 4; + + lengths[type] = length; + lifetimes[type] = lifetime; + scales[type] = scale; + light_levels[type] = light_level; + light_decays[type] = light_decay; + light_colors[type] = light_color; + num_parts[type] = num_part; + part_types[type] = part_type; + part_speeds[type] = part_speed; + part_drags[type] = part_drag; + part_scales[type] = part_scale; + part_blooms[type] = part_bloom; + part_frames[type] = part_nframes; + part_decays[type] = part_decay; + part_rates[type] = part_rate; + part_trails[type] = part_trail; + part_alphas[type] = part_alpha; + recycles[type] = continuous; + + if (length > 0) { + bitmaps[type] = new Bitmap[length]; + + if (length > 1) { + for (int n = 0; n < length; n++) { + char img_name[64]; + sprintf_s(img_name, "%s%02d.pcx", bitmap, n); + loader->LoadBitmap(img_name, bitmaps[type][n], Bitmap::BMP_TRANSLUCENT); + } + } + + else { + loader->LoadBitmap(bitmap, bitmaps[type][0], Bitmap::BMP_TRANSLUCENT); + } + } + + if (particle_bitmap[0]) { + particle_bitmaps[type] = new Bitmap[part_nframes]; + + if (part_nframes > 1) { + for (int i = 0; i < part_nframes; i++) { + char fname[64]; + sprintf_s(fname, "%s%02d.pcx", particle_bitmap, i); + loader->LoadBitmap(fname, particle_bitmaps[type][i], Bitmap::BMP_TRANSLUCENT); + particle_bitmaps[type][i].MakeTexture(); + } + } + + else { + loader->LoadBitmap(particle_bitmap, particle_bitmaps[type][0], Bitmap::BMP_TRANSLUCENT); + particle_bitmaps[type][0].MakeTexture(); + } + } + + if (sound_file[0]) { + loader->SetDataPath("Sounds/"); + loader->LoadSound(sound_file, sounds[type], Sound::LOCALIZED | Sound::LOC_3D); + loader->SetDataPath("Explosions/"); + + if (sounds[type]) { + sounds[type]->SetMinDistance(sound_min_dist); + sounds[type]->SetMaxDistance(sound_max_dist); + } + } + } + } + } + + else + Print("WARNING: unknown definition '%s' in '%s'\n", + def->name()->value().data(), filename); + } + else { + Print("WARNING: term ignored in '%s'\n", filename); + term->print(); + } + } + } + while (term); + + loader->ReleaseBuffer(block); + loader->SetDataPath(0); + initialized = 1; +} + +// +--------------------------------------------------------------------+ + +void +Explosion::Close() +{ + for (int t = 0; t < MAX_EXPLOSION_TYPES; t++) { + if (lengths[t] && bitmaps[t]) { + for (int i = 0; i < lengths[t]; i++) + bitmaps[t][i].ClearImage(); + delete [] bitmaps[t]; + } + + if (particle_bitmaps[t]) { + for (int i = 0; i < part_frames[t]; i++) + particle_bitmaps[t][i].ClearImage(); + delete [] particle_bitmaps[t]; + } + + delete sounds[t]; + } +} + +// +--------------------------------------------------------------------+ + +void +Explosion::ExecFrame(double seconds) +{ + if (source) { + const Matrix& orientation = source->Cam().Orientation(); + MoveTo((mount_rel * orientation) + source->Location()); + + if (rep) rep->Show(); + + if (particles) particles->Show(); + + if (source == Sim::GetSim()->GetPlayerShip()) { + Ship* ship = (Ship*) source; + if (CameraDirector::GetCameraMode() == CameraDirector::MODE_COCKPIT && + !ship->IsDying()) { + if (rep) rep->Hide(); + if (particles) particles->Hide(); + } + } + } + + life -= seconds; + + if (rep) { + rep->MoveTo(Location()); + + if (rep->Life() == 0) { + rep = 0; // about to be GC'd + } + + else if (rep->IsSprite()) { + Sprite* s = (Sprite*) rep; + s->SetAngle(s->Angle() + seconds * 0.5); + } + + else if (type == QUANTUM_FLASH) { + QuantumFlash* q = (QuantumFlash*) rep; + q->SetShade(q->Shade() - seconds); + } + } + + if (light) { + light->Update(); + + if (light->Life() == 0) + light = 0; // about to be GC'd + } + + if (particles) { + particles->MoveTo(Location()); + particles->ExecFrame(seconds); + } + + if (source && source->Life() == 0) + life = 0; +} + +// +--------------------------------------------------------------------+ + +void +Explosion::Activate(Scene& scene) +{ + bool filter = false; + + CameraDirector* cam_dir = CameraDirector::GetInstance(); + if (cam_dir && cam_dir->GetCamera()) { + if (Point(cam_dir->GetCamera()->Pos() - Location()).length() < 100) + filter = true; + } + + if (rep && !filter) + scene.AddGraphic(rep); + + if (light) + scene.AddLight(light); + + if (particles && !filter) + scene.AddGraphic(particles); + + if (sounds[obj_type]) { + Sound* sound = sounds[obj_type]->Duplicate(); + + // fire and forget: + if (sound) { + sound->SetLocation(Location()); + sound->SetVolume(AudioConfig::EfxVolume()); + sound->Play(); + } + } + + active = true; +} + +void +Explosion::Deactivate(Scene& scene) +{ + SimObject::Deactivate(scene); + + if (particles) + scene.DelGraphic(particles); +} + +// +--------------------------------------------------------------------+ + -- cgit v1.1