Moved Stars45 to StarsEx

1 files changed, 0 insertions, 723 deletions

diff --git a/Stars45/Sky.cpp b/Stars45/Sky.cpp
deleted file mode 100644
index ff25044..0000000
--- a/Stars45/Sky.cpp
+++ /dev/null
@@ -1,723 +0,0 @@
-/*  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
-    ========
-    Celestial sphere, stars, planets, space dust...
-*/
-
-#include "Sky.h"
-#include "StarSystem.h"
-
-#include "Clock.h"
-#include "Bitmap.h"
-#include "DataLoader.h"
-#include "Light.h"
-#include "Random.h"
-#include "Utils.h"
-
-
-// +====================================================================+
-
-Stars::Stars(int nstars)
-{
-    infinite = true;
-    luminous = true;
-    shadow   = false;
-
-    vset     = new VertexSet(nstars);
-    colors   = new Color[nstars];
-
-    for (int i = 0; i < nstars; i++) {
-        vset->loc[i]   = RandomVector(1000);
-
-        ColorValue val = ColorValue((float) Random(0.7, 0.8),
-        (float) Random(0.7, 0.8),
-        (float) Random(0.7, 0.8));
-        Color      c   = val.ToColor();
-
-        colors[i]         = c;
-        vset->diffuse[i]  = c.Value();
-        vset->specular[i] = 0;
-    }
-
-    strcpy_s(name, "Stars");
-}
-
-Stars::~Stars()
-{
-    delete [] colors;
-    delete    vset;
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Stars::Illuminate(double scale)
-{
-    if (!vset)
-    return;
-
-    for (int i = 0; i < vset->nverts; i++) {
-        Color c = colors[i] * scale;
-        vset->diffuse[i] = c.Value();
-    }
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Stars::Render(Video* video, DWORD flags)
-{
-    if (!vset || !video || (flags & Graphic::RENDER_ADDITIVE) == 0)
-    return;
-
-    video->SetBlendType(Video::BLEND_ADDITIVE);
-    video->DrawPoints(vset);
-}
-
-// +====================================================================+
-
-static const double BOUNDARY   = 3000;
-static const double BOUNDARYx2 = BOUNDARY * 2;
-
-Dust::Dust(int ndust, bool b)
-    : really_hidden(false), bright(b)
-{
-    radius   = (float) BOUNDARYx2;
-    luminous = true;
-    vset     = new VertexSet(ndust);
-
-    Reset(Point(0, 0, 0));
-    strcpy_s(name, "Dust");
-}
-
-// +--------------------------------------------------------------------+
-
-Dust::~Dust()
-{
-    delete vset;
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Dust::Reset(const Point& ref)
-{
-    BYTE c = 0;
-
-    for (int i = 0; i < vset->nverts; i++) {
-        vset->loc[i] = Vec3( Random(-BOUNDARY, BOUNDARY),
-        Random(-BOUNDARY, BOUNDARY),
-        Random(-BOUNDARY, BOUNDARY) );
-
-        if (bright)
-        c = (BYTE) Random(96,200);
-        else
-        c = (BYTE) Random(64,156);
-
-        vset->diffuse[i]  = Color(c,c,c).Value();
-        vset->specular[i] = 0;
-    }
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Dust::ExecFrame(double factor, const Point& ref)
-{
-    if (Clock::GetInstance()->TimeCompression() > 4.0) {
-        Hide();
-        return;
-    }
-
-    Show();
-
-    Point  delta = ref - loc;
-    double dlen  = delta.length();
-
-    if (dlen < 0.0001)
-    return;
-
-    if (dlen > BOUNDARY) {
-        Reset(ref);
-    }
-    else {
-        // wrap around if necessary to keep in view
-        for (int i = 0; i < vset->nverts; i++) {
-            Vec3 v = vset->loc[i];
-
-            v -= delta;
-
-            if (v.x >  BOUNDARY) v.x -= (float) BOUNDARYx2;
-            if (v.x < -BOUNDARY) v.x += (float) BOUNDARYx2;
-            if (v.y >  BOUNDARY) v.y -= (float) BOUNDARYx2;
-            if (v.y < -BOUNDARY) v.y += (float) BOUNDARYx2;
-            if (v.z >  BOUNDARY) v.z -= (float) BOUNDARYx2;
-            if (v.z < -BOUNDARY) v.z += (float) BOUNDARYx2;
-
-            vset->loc[i] = v;
-        }
-    }
-
-    MoveTo(ref);
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Dust::Render(Video* video, DWORD flags)
-{
-    if (hidden || really_hidden)
-    return;
-
-    if (!vset || !video || (flags & Graphic::RENDER_SOLID) == 0 || (flags & Graphic::RENDER_ADD_LIGHT) != 0)
-    return;
-
-    video->SetBlendType(Video::BLEND_SOLID);
-    video->SetRenderState(Video::Z_ENABLE,       false);
-    video->SetRenderState(Video::Z_WRITE_ENABLE, false);
-
-    video->DrawPoints(vset);
-
-    video->SetRenderState(Video::Z_ENABLE,       true);
-    video->SetRenderState(Video::Z_WRITE_ENABLE, true);
-}
-
-// +--------------------------------------------------------------------+
-
-void
-Dust::Hide()
-{
-    hidden = true;
-    really_hidden = true;
-}
-
-void
-Dust::Show()
-{
-    hidden = false;
-    really_hidden = false;
-}
-
-// +====================================================================+
-
-PlanetRep::PlanetRep(const char* surface_name, const char* glow_name,
-                     double rad, const Vec3& pos, double tscale,
-                     const char* rngname, double minrad, double maxrad,
-                     Color atmos, const char* gloss_name)
-    : mtl_surf(0), mtl_limb(0), mtl_ring(0), star_system(0)
-{
-    loc = pos;
-
-    radius     = (float) rad;
-    has_ring   = 0;
-    ring_verts = -1;
-    ring_polys = -1;
-    ring_rad   = 0;
-    body_rad   = rad;
-    daytime    = false;
-    atmosphere = atmos;
-    star_system = 0;
-
-    if (!surface_name || !*surface_name) {
-        Print("   invalid Planet patch - no surface texture specified\n");
-        return;
-    }
-
-    Print("   constructing Planet patch %s\n", surface_name);
-    strncpy(name, surface_name, 31);
-    name[31] = 0;
-
-    Bitmap*  bmp_surf = 0;
-    Bitmap*  bmp_spec = 0;
-    Bitmap*  bmp_glow = 0;
-    Bitmap*  bmp_ring = 0;
-    Bitmap*  bmp_limb = 0;
-
-    DataLoader* loader = DataLoader::GetLoader();
-    loader->LoadTexture(surface_name, bmp_surf, Bitmap::BMP_SOLID, true);
-
-    if (glow_name && *glow_name) {
-        Print("   loading glow texture %s\n", glow_name);
-        loader->LoadTexture(glow_name, bmp_glow, Bitmap::BMP_SOLID, true);
-    }
-
-    if (gloss_name && *gloss_name) {
-        Print("   loading gloss texture %s\n", gloss_name);
-        loader->LoadTexture(gloss_name, bmp_spec, Bitmap::BMP_SOLID, true);
-    }
-
-    mtl_surf = new Material;
-
-    mtl_surf->Ka            = Color::LightGray;
-    mtl_surf->Kd            = Color::White;
-    mtl_surf->Ke            = bmp_glow ? Color::White     : Color::Black;
-    mtl_surf->Ks            = bmp_spec ? Color::LightGray : Color::Black;
-    mtl_surf->power         = 25.0f;
-    mtl_surf->tex_diffuse   = bmp_surf;
-    mtl_surf->tex_specular  = bmp_spec;
-    mtl_surf->tex_emissive  = bmp_glow;
-    mtl_surf->blend         = Material::MTL_SOLID;
-
-    if (bmp_spec && Video::GetInstance()->IsSpecMapEnabled()) {
-        if (glow_name && strstr(glow_name, "light"))
-        strcpy_s(mtl_surf->shader, "SimplePix/PlanetSurfNightLight");
-
-        else if (glow_name)
-        strcpy_s(mtl_surf->shader, "SimplePix/PlanetSurf");
-    }
-
-    if (atmosphere != Color::Black) {
-        mtl_limb = new Material;
-
-        mtl_limb->Ka = atmosphere;
-
-        strcpy_s(mtl_limb->shader, "PlanetLimb");
-
-        Print("   loading atmospheric limb texture PlanetLimb.pcx\n");
-        loader->LoadTexture("PlanetLimb.pcx", bmp_limb, Bitmap::BMP_TRANSLUCENT, true);
-        mtl_limb->tex_diffuse = bmp_limb;
-        mtl_limb->blend       = Material::MTL_TRANSLUCENT;
-    }
-
-    if (maxrad > 0 && minrad > 0) {
-        has_ring = 1;
-        radius   = (float) maxrad;
-        ring_rad = (maxrad + minrad)/2;
-        loader->LoadTexture(rngname, bmp_ring, Bitmap::BMP_SOLID, true);
-
-        mtl_ring = new Material;
-
-        mtl_ring->Ka            = Color::LightGray;
-        mtl_ring->Kd            = Color::White;
-        mtl_ring->Ks            = Color::Gray;
-        mtl_ring->Ke            = Color::Black;
-        mtl_ring->power         = 30.0f;
-        mtl_ring->tex_diffuse   = bmp_ring;
-        mtl_ring->blend         = Material::MTL_TRANSLUCENT;
-    }
-
-    if (rad > 2e6 && rad < 1e8)
-    CreateSphere(rad, 24, 32, minrad, maxrad, 48, tscale);
-    else
-    CreateSphere(rad, 16, 24, minrad, maxrad, 48, tscale);
-}
-
-// +--------------------------------------------------------------------+
-
-PlanetRep::~PlanetRep()
-{
-}
-
-// +--------------------------------------------------------------------+
-
-void
-PlanetRep::CreateSphere(double radius, int nrings, int nsections,
-double minrad, double maxrad, int rsections,
-double tscale)
-{
-    const int sect_verts = nsections + 1;
-
-    model     = new Model;
-    own_model = 1;
-
-    Surface* surface = new Surface;
-
-    int i, j, m, n;
-
-    int npolys = (nrings + 2) * nsections;
-    int nverts = (nrings + 3) * sect_verts;
-
-    int ppolys = npolys;
-    int pverts = nverts;
-
-    int apolys = 0;
-    int averts = 0;
-
-    if (atmosphere != Color::Black) {
-        apolys = npolys;
-        averts = nverts;
-
-        npolys *= 2;
-        nverts *= 2;
-    }
-
-    if (has_ring) {
-        ring_verts = nverts;
-        ring_polys = npolys;
-
-        npolys += rsections * 3;   // top, bottom, edge
-        nverts += rsections * 6;
-    }
-
-    surface->SetName(name);
-    surface->CreateVerts(nverts);
-    surface->CreatePolys(npolys);
-
-    VertexSet* vset  = surface->GetVertexSet();
-
-    if (!vset || vset->nverts < nverts) {
-        ::Print("WARNING: insufficient memory for planet '%s'\n", name);
-        return;
-    }
-
-    Poly* polys = surface->GetPolys();
-
-    if (!polys) {
-        ::Print("WARNING: insufficient memory for planet '%s'\n", name);
-        return;
-    }
-
-    ZeroMemory(polys, sizeof(Poly) * npolys);
-
-    // Generate vertex points for planetary rings:
-    double dtheta = PI / (nrings + 2);
-    double dphi   = 2 * PI / nsections;
-    double theta  = 0;
-    n = 0; // vertex being generated
-
-    for (i = 0; i < nrings+3; i++) {
-        double y = radius * cos(theta);  // y is the same for entire ring
-        double v = theta / PI;           // v is the same for entire ring
-        double rsintheta = radius * sin(theta);
-        double phi = 0;
-
-        for (j = 0; j < sect_verts; j++) {
-            double x = rsintheta * sin(phi);
-            double z = rsintheta * cos(phi);
-
-            vset->loc[n] = Vec3(x, y, z);
-            vset->nrm[n] = Vec3(x, y, z);
-            vset->tu[n]  = (float) (tscale * (1 - (phi/(2.0*PI))));
-            vset->tv[n]  = (float) (tscale * v);
-
-            vset->nrm[n].Normalize();
-
-            phi += dphi;
-            n++;
-        }
-
-        theta += dtheta;
-    }
-
-    // Generate vertex points for rings:
-    if (has_ring) {
-        n = ring_verts;
-
-        double dphi  = 2.0 * PI / rsections;
-        double y     = 0;  // y is the same for entire ring
-
-        // top of ring:
-        double phi   = 0;
-        for (j = 0; j < rsections; j++) {
-            double x = minrad * sin(phi);
-            double z = minrad * cos(phi);
-
-            vset->loc[n] = Vec3(x, y, z);
-            vset->nrm[n] = Vec3(0, 1, 0);
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 0.0f;
-            n++;
-
-            x = maxrad * sin(phi);
-            z = maxrad * cos(phi);
-
-            vset->loc[n] = Vec3(x, y, z);
-            vset->nrm[n] = Vec3(0, 1, 0);
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 1.0f;
-            n++;
-
-            phi += dphi;
-        }
-
-        // bottom of ring:
-        phi   = 0;
-        for (j = 0; j < rsections; j++) {
-            double x = minrad * sin(phi);
-            double z = minrad * cos(phi);
-
-            vset->loc[n] = Vec3(x, y, z);
-            vset->nrm[n] = Vec3(0, -1, 0);
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 0.0f;
-            n++;
-
-            x = maxrad * sin(phi);
-            z = maxrad * cos(phi);
-
-            vset->loc[n] = Vec3(x, y, z);
-            vset->nrm[n] = Vec3(0, -1, 0);
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 1.0f;
-            n++;
-
-            phi += dphi;
-        }
-
-        // edge of ring:
-        phi   = 0;
-        for (j = 0; j < rsections; j++) {
-            double x = maxrad * sin(phi);
-            double z = maxrad * cos(phi);
-
-            Point normal = Point(x,0,z);
-            normal.Normalize();
-
-            double thickness = maxrad/333;
-
-            vset->loc[n] = Vec3(x, y+thickness, z);
-            vset->nrm[n] = normal;
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 1.0f;
-            n++;
-
-            vset->loc[n] = Vec3(x, y-thickness, z);
-            vset->nrm[n] = normal;
-            vset->tu[n]  = (j & 1) ? 1.0f : 0.0f;
-            vset->tv[n]  = 1.0f;
-            n++;
-
-            phi += dphi;
-        }
-    }
-
-    for (i = 0; i < npolys; i++) {
-        polys[i].nverts      = 3;
-        polys[i].vertex_set  = vset;
-        polys[i].material    = mtl_surf;
-    }
-
-    // Generate triangles for top and bottom caps.
-    for (i = 0; i < nsections; i++) {
-        Poly& p0 = polys[i];
-        p0.verts[2]          = i;
-        p0.verts[1]          = sect_verts + i;
-        p0.verts[0]          = sect_verts + ((i+1) % sect_verts);
-
-        Poly& p1 = polys[ppolys - nsections + i];
-        p1.verts[2]          = pverts - 1 - i;
-        p1.verts[1]          = pverts - 1 - sect_verts - i;
-        p1.verts[0]          = pverts - 2 - sect_verts - i;
-
-        surface->AddIndices(6);
-    }
-
-    // Generate triangles for the planetary rings
-    m = sect_verts;   // first vertex in current ring
-    n = nsections;    // triangle being generated, skip the top cap
-
-    for (i = 0; i < nrings; i++) {
-        for (j = 0; j < nsections; j++) {
-            Poly& p0 = polys[n];
-            p0.nverts            = 4;
-            p0.verts[3]          = m + j;
-            p0.verts[2]          = m + (sect_verts) + j;
-            p0.verts[1]          = m + (sect_verts) + ((j + 1) % (sect_verts));
-            p0.verts[0]          = m + ((j + 1) % (sect_verts));
-            n++;
-
-            surface->AddIndices(6);
-        }
-
-        m += sect_verts;
-    }
-
-    if (averts && apolys && mtl_limb) {
-        for (i = 0; i < pverts; i++) {
-            vset->loc[averts + i] = vset->loc[i];
-            vset->nrm[averts + i] = vset->nrm[i];
-        }
-
-        for (i = 0; i < ppolys; i++) {
-            Poly& p0 = polys[i];
-            Poly& p1 = polys[apolys + i];
-
-            p1.vertex_set  = vset;
-            p1.material    = mtl_limb;
-
-            p1.nverts      = p0.nverts;
-            p1.verts[0]    = p0.verts[0];
-            p1.verts[1]    = p0.verts[1];
-            p1.verts[2]    = p0.verts[2];
-            p1.verts[3]    = p0.verts[3];
-
-            surface->AddIndices(p1.nverts == 3 ? 3 : 6);
-        }
-    }
-
-    if (has_ring) {
-        // Generate quads for the rings
-        m = ring_verts;    // first vertex in top of ring, after planet verts
-        n = ring_polys;    // quad being generated, after planet polys
-
-        // top of ring:
-        for (j = 0; j < rsections; j++) {
-            Poly& p0 = polys[n];
-            p0.nverts            = 4;
-            p0.material          = mtl_ring;
-
-            p0.verts[3]          = m + 2*j;
-            p0.verts[2]          = m + 2*j + 1;
-            p0.verts[1]          = m + ((2*j + 3) % (rsections*2));
-            p0.verts[0]          = m + ((2*j + 2) % (rsections*2));
-
-            surface->AddIndices(6);
-
-            n++;
-        }
-
-        // bottom of ring:
-        // first vertex in bottom of ring, after top ring verts
-        m = ring_verts + 2*rsections;
-
-        for (j = 0; j < rsections; j++) {
-            Poly& p0 = polys[n];
-            p0.nverts            = 4;
-            p0.material          = mtl_ring;
-
-            p0.verts[0]          = m + 2*j;
-            p0.verts[1]          = m + 2*j + 1;
-            p0.verts[2]          = m + ((2*j + 3) % (rsections*2));
-            p0.verts[3]          = m + ((2*j + 2) % (rsections*2));
-
-            surface->AddIndices(6);
-
-            n++;
-        }
-
-        // edge of ring:
-        // first vertex in edge of ring, after bottom ring verts
-        m = ring_verts + 4*rsections;
-
-        for (j = 0; j < rsections; j++) {
-            Poly& p0 = polys[n];
-            p0.nverts            = 4;
-            p0.material          = mtl_ring;
-
-            p0.verts[3]          = m + 2*j;
-            p0.verts[2]          = m + 2*j + 1;
-            p0.verts[1]          = m + ((2*j + 3) % (rsections*2));
-            p0.verts[0]          = m + ((2*j + 2) % (rsections*2));
-
-            surface->AddIndices(6);
-
-            n++;
-        }
-    }
-
-    // then assign them to cohesive segments:
-    Segment* segment = 0;
-
-    for (n = 0; n < npolys; n++) {
-        Poly& poly  = polys[n];
-        poly.plane  = Plane(vset->loc[poly.verts[0]],
-        vset->loc[poly.verts[2]],
-        vset->loc[poly.verts[1]]);
-
-        if (segment && segment->material == polys[n].material) {
-            segment->npolys++;
-        }
-        else {
-            segment = new Segment;
-
-            segment->npolys   = 1;
-            segment->polys    = &polys[n];
-            segment->material = segment->polys->material;
-
-            surface->GetSegments().append(segment);
-        }
-    }
-
-    model->AddSurface(surface);
-}
-
-
-int
-PlanetRep::CheckRayIntersection(Point Q, Point w, double len, Point& ipt,
-bool treat_translucent_polys_as_solid)
-{
-    // compute leading edge of ray:
-    Point  dst = Q + w*len;
-
-    // check right angle spherical distance:
-    Point  d0 = loc - Q;
-    Point  d1 = d0.cross(w);
-    double dlen = d1.length();          // distance of point from line
-
-    if (dlen > body_rad)                // clean miss
-    return 0;                        // (no impact)
-
-    // possible collision course...
-    Point d2     = Q + w * (d0 * w);
-
-    // so check the leading edge:
-    Point delta0 = dst - loc;
-
-    if (delta0.length() > radius) {
-        // and the endpoints:
-        Point delta1 = d2  - Q;
-        Point delta2 = dst - Q;
-
-        // if d2 is not between Q and dst, we missed:
-        if (delta1 * delta2 < 0 ||
-                delta1.length() > delta2.length()) {
-            return 0;
-        }
-    }
-
-    return 1;
-}
-
-void
-PlanetRep::SetDaytime(bool d)
-{
-    daytime = d;
-
-    if (daytime) {
-        if (mtl_surf)  mtl_surf->blend = Material::MTL_ADDITIVE;
-        if (mtl_ring)  mtl_ring->blend = Material::MTL_ADDITIVE;
-    }
-
-    else {
-        if (mtl_surf)  mtl_surf->blend = Material::MTL_SOLID;
-        if (mtl_ring)  mtl_ring->blend = Material::MTL_TRANSLUCENT;
-    }
-}
-
-void
-PlanetRep::SetStarSystem(StarSystem* system)
-{
-    star_system = system;
-}
-
-// +--------------------------------------------------------------------+
-
-void
-PlanetRep::Render(Video* video, DWORD flags)
-{
-    Solid::Render(video, flags);
-
-    /***
-    *** DEBUG
-    ***
-
-Matrix orient  = Orientation();
-orient.Transpose();
-
-video->SetObjTransform(orient, Location());
-
-Surface* surf  = model->GetSurfaces().first();
-Poly*    polys = surf->GetPolys();
-
-for (int i = 0; i < 5; i++)
-    video->DrawPolyOutline(polys + i);
-/***/
-}
-