Moved Stars45 to StarsEx

1 files changed, 800 insertions, 0 deletions

diff --git a/StarsEx/CameraView.cpp b/StarsEx/CameraView.cpp
new file mode 100644
index 0000000..9f58dd8
--- /dev/null
+++ b/StarsEx/CameraView.cpp
@@ -0,0 +1,800 @@
+/*  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
+    ========
+    3D Projection Camera View class
+    uses abstract PolyRender class to draw the triangles
+*/
+
+#include "CameraView.h"
+#include "Color.h"
+#include "Window.h"
+#include "Scene.h"
+#include "Light.h"
+#include "Solid.h"
+#include "Shadow.h"
+#include "Sprite.h"
+#include "Video.h"
+#include "Bitmap.h"
+#include "Screen.h"
+#include "Game.h"
+#include "Utils.h"
+
+// +--------------------------------------------------------------------+
+
+static Camera  emergency_cam;
+static Scene   emergency_scene;
+
+// +--------------------------------------------------------------------+
+
+CameraView::CameraView(Window* c, Camera* cam, Scene* s)
+    : View(c), video(0), camera(cam), projector(c, cam), scene(s),
+      lens_flare_enable(0), halo_bitmap(0),  infinite(0),
+      projection_type(Video::PROJECTION_PERSPECTIVE)
+{
+    elem_bitmap[0] = 0;
+    elem_bitmap[1] = 0;
+    elem_bitmap[2] = 0;
+
+    if (!camera)
+    camera = &emergency_cam;
+
+    if (!scene)
+    scene = &emergency_scene;
+
+    Rect r = window->GetRect();
+    width  = r.w;
+    height = r.h;
+}
+
+CameraView::~CameraView()
+{
+}
+
+// +--------------------------------------------------------------------+
+
+void
+CameraView::UseCamera(Camera* cam)
+{
+    if (cam)
+    camera = cam;
+    else
+    camera = &emergency_cam;
+
+    projector.UseCamera(camera);
+}
+
+void
+CameraView::UseScene(Scene* s)
+{
+    if (s)
+    scene = s;
+    else
+    scene = &emergency_scene;
+}
+
+void
+CameraView::SetFieldOfView(double fov)
+{
+    projector.SetFieldOfView(fov);
+}
+
+double
+CameraView::GetFieldOfView() const
+{
+    return projector.GetFieldOfView();
+}
+
+void
+CameraView::SetProjectionType(DWORD pt)
+{
+    projector.SetOrthogonal(pt == Video::PROJECTION_ORTHOGONAL);
+    projection_type = pt;
+}
+
+DWORD
+CameraView::GetProjectionType() const
+{
+    return projection_type;
+}
+
+void
+CameraView::OnWindowMove()
+{
+    Rect r = window->GetRect();
+    projector.UseWindow(window);
+
+    width  = r.w;
+    height = r.h;
+}
+
+
+// +--------------------------------------------------------------------+
+// Enable or disable lens flare effect, and provide bitmaps for rendering
+// +--------------------------------------------------------------------+
+
+void
+CameraView::LensFlare(int on, double dim)
+{
+    lens_flare_enable = on;
+    lens_flare_dim    = dim;
+}
+
+void
+CameraView::LensFlareElements(Bitmap* halo, Bitmap* e1, Bitmap* e2, Bitmap* e3)
+{
+    if (halo)
+    halo_bitmap = halo;
+
+    if (e1)
+    elem_bitmap[0] = e1;
+
+    if (e2)
+    elem_bitmap[1] = e2;
+
+    if (e3)
+    elem_bitmap[2] = e3;
+}
+
+// +--------------------------------------------------------------------+
+
+int
+CameraView::SetInfinite(int i)
+{
+    int old = infinite;
+    infinite = i;
+    projector.SetInfinite(i);
+    return old;
+}
+
+// +--------------------------------------------------------------------+
+// Compute the Depth of a Graphic
+// +--------------------------------------------------------------------+
+
+void
+CameraView::FindDepth(Graphic* g)
+{
+    if (infinite) {
+        g->SetDepth(1.0e20f);
+        return;
+    }
+
+    // Translate into a viewpoint-relative coordinate
+    Vec3 loc = g->Location() - camera->Pos();
+
+    // Rotate into the view orientation
+    float z = (float) (loc * camera->vpn());
+    g->SetDepth(z);
+}
+
+// +--------------------------------------------------------------------+
+
+void
+CameraView::Refresh()
+{
+    // disabled:
+    if (camera == &emergency_cam)
+    return;
+
+    // prologue:
+    video = Video::GetInstance();
+    if (!video)
+    return;
+
+    int cw = window->Width();
+    int ch = window->Height();
+
+    cvrt = camera->vrt();
+    cvup = camera->vup();
+    cvpn = camera->vpn();
+
+    TranslateScene();
+    MarkVisibleObjects();
+
+    Rect old_rect;
+    video->GetWindowRect(old_rect);
+
+    video->SetCamera(camera);
+    video->SetWindowRect(window->GetRect());
+    video->SetProjection((float) GetFieldOfView(), 1.0f, 1.0e6f, projection_type);
+
+    // project and render:
+    RenderBackground();
+    RenderScene();
+    RenderForeground();
+    RenderSprites();
+    RenderLensFlare();
+
+    UnTranslateScene();
+
+    video->SetWindowRect(old_rect);
+}
+
+// +--------------------------------------------------------------------+
+// Translate all objects and lights to camera relative coordinates:
+// +--------------------------------------------------------------------+
+
+void
+CameraView::TranslateScene()
+{
+    camera_loc = camera->Pos();
+
+    ListIter<Graphic> g_iter = scene->Graphics();
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+
+        if (!graphic->IsInfinite())
+        graphic->TranslateBy(camera_loc);
+    }
+
+    g_iter.attach(scene->Foreground());
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+        graphic->TranslateBy(camera_loc);
+    }
+
+    g_iter.attach(scene->Sprites());
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+
+        if (!graphic->IsInfinite())
+        graphic->TranslateBy(camera_loc);
+    }
+
+    ListIter<Light> l_iter = scene->Lights();
+    while (++l_iter) {
+        Light* light = l_iter.value();
+        light->TranslateBy(camera_loc);
+    }
+
+    camera->MoveTo(0,0,0);
+}
+
+// +--------------------------------------------------------------------+
+// Translate all objects and lights back to original positions:
+// +--------------------------------------------------------------------+
+
+void
+CameraView::UnTranslateScene()
+{
+    Point reloc = -camera_loc;
+
+    ListIter<Graphic> g_iter = scene->Graphics();
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+
+        if (!graphic->IsInfinite())
+        graphic->TranslateBy(reloc);
+    }
+
+    g_iter.attach(scene->Foreground());
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+        graphic->TranslateBy(reloc);
+    }
+
+    g_iter.attach(scene->Sprites());
+    while (++g_iter) {
+        Graphic* graphic = g_iter.value();
+
+        if (!graphic->IsInfinite())
+        graphic->TranslateBy(reloc);
+    }
+
+    ListIter<Light> l_iter = scene->Lights();
+    while (++l_iter) {
+        Light* light = l_iter.value();
+        light->TranslateBy(reloc);
+    }
+
+    camera->MoveTo(camera_loc);
+}
+
+// +--------------------------------------------------------------------+
+// Mark visible objects
+// +--------------------------------------------------------------------+
+
+void
+CameraView::MarkVisibleObjects()
+{
+    projector.StartFrame();
+    graphics.clear();
+
+    ListIter<Graphic> graphic_iter = scene->Graphics();
+    while (++graphic_iter) {
+        Graphic* graphic = graphic_iter.value();
+
+        if (graphic->Hidden())
+        continue;
+
+        if (graphic->CheckVisibility(projector)) {
+            graphic->Update();
+            graphics.append(graphic);
+        }
+        else {
+            graphic->ProjectScreenRect(0);
+        }
+    }
+}
+
+void
+CameraView::MarkVisibleLights(Graphic* graphic, DWORD flags)
+{
+    if (flags < Graphic::RENDER_FIRST_LIGHT) {
+        flags = flags | Graphic::RENDER_FIRST_LIGHT | Graphic::RENDER_ADD_LIGHT;
+    }
+
+    if (graphic->IsVisible()) {
+        Vec3 eye = camera->Pos();
+
+        ListIter<Light> light_iter = scene->Lights();
+
+        while (++light_iter) {
+            Light* light = light_iter.value();
+            bool bright_enough = light->Type()      == Light::LIGHT_DIRECTIONAL ||
+            light->Intensity() >= 1e9;
+
+            if (!bright_enough) {
+                Point test = graphic->Location() - light->Location();
+                if (test.length() < light->Intensity()*10)
+                bright_enough = true;
+            }
+
+            // turn off lights that won't be used this pass:
+            if (light->CastsShadow()) {
+                if ((flags & Graphic::RENDER_ADD_LIGHT) == 0)
+                bright_enough = false;
+            }
+            else {
+                if ((flags & Graphic::RENDER_FIRST_LIGHT) == 0)
+                bright_enough = false;
+            }
+
+            double obs_radius = graphic->Radius();
+            if (obs_radius < 100)
+            obs_radius = 100;
+
+            light->SetActive(bright_enough);
+        }
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+CameraView::RenderBackground()
+{
+    if (scene->Background().isEmpty()) return;
+
+    video->SetRenderState(Video::FILL_MODE,         Video::FILL_SOLID);
+    video->SetRenderState(Video::Z_ENABLE,          FALSE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    FALSE);
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::LIGHTING_ENABLE,   TRUE);
+
+    // solid items:
+    ListIter<Graphic> iter = scene->Background();
+    while (++iter) {
+        Graphic* g = iter.value();
+
+        if (!g->Hidden())
+        Render(g, Graphic::RENDER_SOLID);
+    }
+
+    // blended items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+
+        if (!g->Hidden())
+        Render(g, Graphic::RENDER_ALPHA);
+    }
+
+    // glowing items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+
+        if (!g->Hidden())
+        Render(g, Graphic::RENDER_ADDITIVE);
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+CameraView::RenderForeground()
+{
+    bool foregroundVisible = false;
+
+    ListIter<Graphic> iter = scene->Foreground();
+    while (++iter && !foregroundVisible) {
+        Graphic* g = iter.value();
+        if (g && !g->Hidden())
+        foregroundVisible = true;
+    }
+
+    if (!foregroundVisible)
+    return;
+
+    video->SetRenderState(Video::FILL_MODE,         Video::FILL_SOLID);
+    video->SetRenderState(Video::Z_ENABLE,          TRUE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    TRUE);
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::LIGHTING_ENABLE,   TRUE);
+    video->SetProjection((float) GetFieldOfView(), 1.0f,   1.0e6f,  projection_type);
+
+    if (video->IsShadowEnabled() || video->IsBumpMapEnabled()) {
+        // solid items, ambient and non-shadow lights:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+            Render(g, Graphic::RENDER_SOLID | Graphic::RENDER_FIRST_LIGHT);
+        }
+
+        video->SetAmbient(Color::Black);
+        video->SetRenderState(Video::LIGHTING_PASS,     2);
+
+        // solid items, shadow lights:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+            Render(g, Graphic::RENDER_SOLID | Graphic::RENDER_ADD_LIGHT);
+        }
+    }
+
+    else {
+        // solid items:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+            Render(g, Graphic::RENDER_SOLID);
+        }
+    }
+
+    video->SetAmbient(scene->Ambient());
+    video->SetRenderState(Video::LIGHTING_PASS,     0);
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::Z_ENABLE,          TRUE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    FALSE);
+
+    // blended items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+        Render(g, Graphic::RENDER_ALPHA);
+        g->ProjectScreenRect(&projector);
+    }
+
+    // glowing items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+        Render(g, Graphic::RENDER_ADDITIVE);
+        g->ProjectScreenRect(&projector);
+    }
+}
+
+// +--------------------------------------------------------------------+
+
+void
+CameraView::RenderSprites()
+{
+    if (scene->Sprites().isEmpty()) return;
+
+    video->SetRenderState(Video::FILL_MODE,         Video::FILL_SOLID);
+    video->SetRenderState(Video::Z_ENABLE,          TRUE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    FALSE);
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::LIGHTING_ENABLE,   TRUE);
+
+    // compute depth:
+    ListIter<Graphic> iter = scene->Sprites();
+    while (++iter) {
+        Graphic* g = iter.value();
+        if (g && g->IsVisible() && !g->Hidden()) {
+            FindDepth(g);
+        }
+    }
+
+    // sort the list:
+    scene->Sprites().sort();
+
+    // blended items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+        Render(g, Graphic::RENDER_ALPHA);
+    }
+
+    // glowing items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+        Render(g, Graphic::RENDER_ADDITIVE);
+    }
+}
+
+// +--------------------------------------------------------------------+
+// Render the whole scene, sorted back to front
+// +--------------------------------------------------------------------+
+
+void
+CameraView::RenderScene()
+{
+    if (graphics.isEmpty()) return;
+
+    int   i         = 0;
+    int   ngraphics = graphics.size();
+
+    // compute depth:
+    ListIter<Graphic> iter = graphics;
+    while (++iter) {
+        Graphic* g = iter.value();
+        if (g && !g->Hidden()) {
+            FindDepth(g);
+
+            if (g->IsSolid()) {
+                Solid* solid = (Solid*) g;
+
+                solid->SelectDetail(&projector);
+
+                if (video->IsShadowEnabled()) {
+                    MarkVisibleLights(solid, Graphic::RENDER_ADD_LIGHT);
+                    solid->UpdateShadows(scene->Lights());
+                }
+            }
+        }
+    }
+
+    // sort the list:
+    graphics.sort();
+
+    Graphic* g = graphics.last();
+    if (g->Depth() > 5e6) {
+        RenderSceneObjects(true);
+        video->ClearDepthBuffer();
+    }
+
+    RenderSceneObjects(false);
+}
+
+void
+CameraView::RenderSceneObjects(bool distant)
+{
+    ListIter<Graphic> iter = graphics;
+
+    video->SetAmbient(scene->Ambient());
+    video->SetRenderState(Video::FILL_MODE,         Video::FILL_SOLID);
+    video->SetRenderState(Video::Z_ENABLE,          TRUE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    TRUE);
+    video->SetRenderState(Video::LIGHTING_ENABLE,   TRUE);
+
+    if (distant)
+    video->SetProjection((float) GetFieldOfView(), 5.0e6f, 1.0e12f, projection_type);
+    else
+    video->SetProjection((float) GetFieldOfView(), 1.0f,   1.0e6f,  projection_type);
+
+    if (video->IsShadowEnabled() || video->IsBumpMapEnabled()) {
+        // solid items, ambient and non-shadow lights:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+
+            if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+                Render(g, Graphic::RENDER_SOLID | Graphic::RENDER_FIRST_LIGHT);
+            }
+        }
+
+        // send shadows to stencil buffer:
+        if (video->IsShadowEnabled()) {
+            iter.reset();
+            while (++iter) {
+                Graphic* g = iter.value();
+                if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+                    if (g->IsSolid()) {
+                        Solid* solid = (Solid*) g;
+
+                        ListIter<Shadow> shadow_iter = solid->GetShadows();
+                        while (++shadow_iter) {
+                            Shadow* shadow = shadow_iter.value();
+                            shadow->Render(video);
+                        }
+                    }
+                }
+            }
+        }
+
+        video->SetAmbient(Color::Black);
+        video->SetRenderState(Video::LIGHTING_PASS,     2);
+        video->SetRenderState(Video::STENCIL_ENABLE,    TRUE);
+
+        // solid items, shadow lights:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+
+            if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+                Render(g, Graphic::RENDER_SOLID | Graphic::RENDER_ADD_LIGHT);
+            }
+        }
+    }
+
+    else {
+        // solid items:
+        iter.reset();
+        while (++iter) {
+            Graphic* g = iter.value();
+
+            if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+                Render(g, Graphic::RENDER_SOLID);
+            }
+        }
+    }
+
+    video->SetAmbient(scene->Ambient());
+    video->SetRenderState(Video::LIGHTING_PASS,     0);
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::Z_ENABLE,          TRUE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    FALSE);
+
+    // blended items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+
+        if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+            Render(g, Graphic::RENDER_ALPHA);
+            g->ProjectScreenRect(&projector);
+        }
+    }
+
+    // glowing items:
+    iter.reset();
+    while (++iter) {
+        Graphic* g = iter.value();
+
+        if (distant && g->Depth() > 5e6 || !distant && g->Depth() < 5e6) {
+            Render(g, Graphic::RENDER_ADDITIVE);
+            g->ProjectScreenRect(&projector);
+        }
+    }
+}
+
+void
+CameraView::Render(Graphic* g, DWORD flags)
+{
+    if (g && g->IsVisible() && !g->Hidden()) {
+        if (g->IsSolid()) {
+            MarkVisibleLights(g, flags);
+            video->SetLights(scene->Lights());
+        }
+
+        g->Render(video, flags);
+    }
+}
+
+// +--------------------------------------------------------------------+
+// Draw the lens flare effect, if enabled and light source visible
+// +--------------------------------------------------------------------+
+
+void
+CameraView::RenderLensFlare()
+{
+    if (!lens_flare_enable || lens_flare_dim < 0.01)
+    return;
+
+    if (!halo_bitmap)
+    return;
+
+    video->SetRenderState(Video::STENCIL_ENABLE,    FALSE);
+    video->SetRenderState(Video::Z_ENABLE,          FALSE);
+    video->SetRenderState(Video::Z_WRITE_ENABLE,    FALSE);
+
+    Vec3 flare_pos;
+    Vec3 sun_pos;
+    Vec3 center((float)width/2.0f, (float)height/2.0f, 1.0f);
+    int  flare_visible = 0;
+
+    ListIter<Light> light_iter = scene->Lights();
+    while (++light_iter) {
+        Light* light = light_iter.value();
+
+        if (!light->IsActive())
+        continue;
+
+        if (light->Type() == Light::LIGHT_DIRECTIONAL && light->Intensity() < 1)
+        continue;
+
+        double distance = (light->Location()-camera->Pos()).length();
+
+        // only do lens flare for the sun:
+        if (distance > 1e9) {
+            if (projector.IsVisible(light->Location(), 1.0f)) {
+                // FOUND IT: TRANSFORM/PROJECT FLARE LOCATION
+                Point sun_pos = light->Location();
+
+                if (light->CastsShadow() && scene->IsLightObscured(camera->Pos(), sun_pos, -1))
+                continue;
+
+                projector.Transform(sun_pos);
+
+                if (sun_pos.z < 100)
+                continue;
+
+                projector.Project(sun_pos, false);
+
+                int x = (int) (sun_pos.x);
+                int y = (int) (sun_pos.y);
+                int w = (int) (window->Width() / 4.0);
+                int h = w;
+
+                // halo:
+                window->DrawBitmap(x-w,y-h,x+w,y+h, halo_bitmap, Video::BLEND_ADDITIVE);
+
+                // lens elements:
+                if (elem_bitmap[0]) {
+                    Point vector = center - sun_pos;
+                    float vlen = (float) vector.length();
+                    vector.Normalize();
+
+                    static int   nelem = 12;
+                    static int   elem_indx[] = {  0,    1,    1,     1,     0,      0,     0,    0,    2,    0,    0,    2    };
+                    static float elem_dist[] = { -0.2f, 0.5f, 0.55f, 0.62f, 1.23f, 1.33f, 1.35f, 0.8f, 0.9f, 1.4f, 1.7f, 1.8f };
+                    static float elem_size[] = {  0.3f, 0.2f, 0.4f,  0.3f,  0.4f,  0.2f,  0.6f,  0.1f, 0.1f, 1.6f, 1.0f, 0.2f };
+
+                    for (int elem = 0; elem < nelem; elem++) {
+                        Bitmap* img = elem_bitmap[elem_indx[elem]];
+
+                        /***
+                if (elem == 10)
+                    shade *= 0.5;
+                ***/
+
+                        if (img == 0)
+                        img = elem_bitmap[0];
+
+                        flare_pos = sun_pos + (vector * elem_dist[elem] * vlen);
+                        x = (int) (flare_pos.x);
+                        y = (int) (flare_pos.y);
+                        w = (int) (window->Width() / 8.0 * elem_size[elem]);
+                        h = w;
+
+                        window->DrawBitmap(x-w,y-h,x+w,y+h, img, Video::BLEND_ADDITIVE);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// +--------------------------------------------------------------------+
+// Rotate and translate a plane in world space to view space.
+// +--------------------------------------------------------------------+
+
+void
+CameraView::WorldPlaneToView(Plane& plane)
+{
+    // Determine the distance from the viewpoint
+    Vec3 tnormal = plane.normal;
+
+    if (!infinite)
+    plane.distance -= (float) (camera->Pos() * tnormal);
+
+    // Rotate the normal into view orientation
+    plane.normal.x = tnormal * cvrt;
+    plane.normal.y = tnormal * cvup;
+    plane.normal.z = tnormal * cvpn;
+}
+
+void
+CameraView::SetDepthScale(float scale)
+{
+    projector.SetDepthScale(scale);
+}