Implement SP #293 quad line drawing

src/ai/ai.cpp

@@ -41,20 +41,20 @@ void ShipAI::drawOnGMRadar(sp::RenderTarget& renderer, glm::vec2 draw_position,
     auto transform = owner.getComponent<sp::Transform>();
     if (!transform) return;
     auto world_position = transform->getPosition();
-    auto target = owner.getComponent<Target>();
-    if (target)
+    if (auto target = owner.getComponent<Target>())
     {
-        if (auto t = target->entity.getComponent<sp::Transform>()) {
+        if (auto t = target->entity.getComponent<sp::Transform>())
+        {
             auto v = t->getPosition() - world_position;
-            renderer.drawLine(draw_position, draw_position + v * scale, glm::u8vec4(255, 128, 128, 64));
+            renderer.drawLine(draw_position, draw_position + v * scale, 1.0f, glm::u8vec4(255, 128, 128, 64));
         }
     }
 
     auto p0 = draw_position;
     for(unsigned int n=0; n<pathPlanner.route.size(); n++)
     {
         auto p1 = draw_position + (pathPlanner.route[n] - world_position) * scale;
-        renderer.drawLine(p0, p1, glm::u8vec4(255, 255, 255, 64));
+        renderer.drawLine(p0, p1, 1.0f, glm::u8vec4(255, 255, 255, 64));
         p0 = p1;
     }
 }

src/gui/debugRenderer.cpp

@@ -103,13 +103,14 @@ void DebugRenderer::render(sp::RenderTarget& renderer)
         }
 
         int index = 0;
-        for(const auto& key : key_order) {
-            renderer.drawLine(points[key], line_colors[index % 6]);
+        for (const auto& key : key_order)
+        {
+            renderer.drawLine(points[key], 1.0f, line_colors[index % 6]);
             index += 1;
         }
 
-        //60FPS line
-        renderer.drawLine({0, window_size.y - 166}, {window_size.x, window_size.y - 166}, glm::u8vec4{255,255,255,128});
+        // 60 FPS line
+        renderer.drawLine({0, window_size.y - 166}, {window_size.x, window_size.y - 166}, 2.0f, glm::u8vec4{255,255,255,128});
 
         index = 0;
         for(const auto& key : key_order) {

src/gui/gui2_container.cpp

@@ -50,7 +50,7 @@ void GuiContainer::drawDebugElements(sp::Rect parent_rect, sp::RenderTarget& ren
         if (element->visible)
         {
             renderer.fillRect(element->rect, glm::u8vec4(255, 255, 255, 5));
-            renderer.outlineRect(element->rect, glm::u8vec4(255, 0, 255, 255));
+            renderer.drawRectOutline(element->rect, 1.0f, glm::u8vec4(255, 0, 255, 255));
 
             element->drawDebugElements(element->rect, renderer);
 

src/init/config.cpp

@@ -2,6 +2,7 @@
 #include <stringImproved.h>
 #include <io/keybinding.h>
 #include <preferenceManager.h>
+#include <graphics/renderTarget.h>
 #include "gui/colorConfig.h"
 #include "gui/hotkeyConfig.h"
 #include <cstring>
@@ -50,5 +51,6 @@ string initConfiguration(int argc, char** argv)
     }
 
     sp::io::Keybinding::loadKeybindings(configuration_path + "/keybindings.json");
+
     return configuration_path;
 }

src/main.cpp

@@ -243,11 +243,17 @@ int main(int argc, char** argv)
 
     engine->runMainLoop();
 
-    // Set FSAA and fullscreen defaults from windowManager.
+    // Set FSAA and fullscreen defaults from windowManager, and line drawing
+    // defaults from renderTarget.
     if (windows.size() > 0)
     {
         PreferencesManager::set("fsaa", windows[0]->getFSAA());
         PreferencesManager::set("fullscreen", (int)windows[0]->getMode());
+
+        if (PreferencesManager::get("line_drawing_mode", "quad") == "quad")
+            sp::RenderTarget::setLineDrawingMode(sp::RenderTarget::LineDrawingMode::Quad);
+        else
+            sp::RenderTarget::setLineDrawingMode(sp::RenderTarget::LineDrawingMode::GL);
     }
 
     // Set the default music_, sound_, and engine_volume to the current volume.

src/menus/optionsMenu.cpp

@@ -6,6 +6,7 @@
 #include "preferenceManager.h"
 #include "soundManager.h"
 #include "windowManager.h"
+#include "graphics/renderTarget.h"
 
 #include "gui/theme.h"
 #include "gui/gui2_overlay.h"
@@ -364,6 +365,26 @@ void OptionsMenu::setupGraphicsOptions()
     (new GuiLabel(graphics_page, "THEME_APPLICATION_LABEL", tr("Restart EmptyEpsilon to apply FSAA change"), 20.0f))
         ->setSize(GuiElement::GuiSizeMax, 30.0f);
 
+    // Line drawing mode selector.
+    int line_mode_index = (sp::RenderTarget::getLineDrawingMode() == sp::RenderTarget::LineDrawingMode::GL) ? 0 : 1;
+    (new GuiSelector(graphics_page, "GRAPHICS_LINE_DRAWING_MODE",
+        [](int index, string value)
+        {
+            if (index == 1)
+            {
+                PreferencesManager::set("line_drawing_mode", "quad");
+                sp::RenderTarget::setLineDrawingMode(sp::RenderTarget::LineDrawingMode::Quad);
+            }
+            else
+            {
+                PreferencesManager::set("line_drawing_mode", "gl");
+                sp::RenderTarget::setLineDrawingMode(sp::RenderTarget::LineDrawingMode::GL);
+            }
+        }
+    ))->setOptions({tr("options", "Line rendering: Quads (High quality)"), tr("options", "Line rendering: GL (Low quality)")})
+        ->setSelectionIndex(line_mode_index)
+        ->setSize(GuiElement::GuiSizeMax, 50.0f);
+
     // FoV slider.
     auto initial_fov = PreferencesManager::get("main_screen_camera_fov", "60").toFloat();
     graphics_fov_slider = new GuiBasicSlider(graphics_page, "GRAPHICS_FOV_SLIDER", 30.f, 140.0f, initial_fov, [this](float fov) {

src/screenComponents/radarView.cpp

@@ -149,17 +149,13 @@ void GuiRadarView::onDraw(sp::RenderTarget& renderer)
 
     // Draw the initial background 'clear' color.
     if (style == Rectangular)
-    {
         drawBackground(renderer);
-    }
 
-    if ((style == CircularMasked || style == Circular))
-    {
-        // Draw the radar's outline. First, and before any stencil kicks in.
-        // this way, the outline is not even a part of the rendering area.
-        float r = std::min(rect.size.x, rect.size.y) * 0.5f;
-        renderer.drawCircleOutline(getCenterPoint(), r, 2.0f, colorConfig.radar_outline);
-    }
+    // Draw the radar's outline first, and before any stencil kicks in.
+    // This way, the outline is not even part of the rendering area.
+    const float radar_outline_thickness = 4.0f;
+    if (style == CircularMasked || style == Circular)
+        renderer.drawCircleOutline(getCenterPoint(), std::min(rect.size.x, rect.size.y) * 0.5f, radar_outline_thickness, colorConfig.radar_outline);
 
     // Stencil setup.
     renderer.finish();
@@ -191,7 +187,7 @@ void GuiRadarView::onDraw(sp::RenderTarget& renderer)
 
         // Draws the radar circle shape.
         // Note that this draws both in the stencil and the color buffer!
-        renderer.fillCircle(getCenterPoint(), std::min(rect.size.x, rect.size.y) / 2.0f - 2.0f, glm::u8vec4{ 20, 20, 20, background_alpha });
+        renderer.fillCircle(getCenterPoint(), std::min(rect.size.x, rect.size.y) * 0.5f - radar_outline_thickness, glm::u8vec4{20, 20, 20, background_alpha});
         renderer.finish();
     }
 
@@ -330,8 +326,8 @@ void GuiRadarView::drawSectorGrid(sp::RenderTarget& renderer)
     auto radar_screen_center = rect.center();
     float scale = std::min(rect.size.x, rect.size.y) / 2.0f / distance;
 
-    constexpr float sector_size = 20000;
-    const float sub_sector_size = sector_size / 8;
+    constexpr float sector_size = 20000.0f;
+    const float sub_sector_size = sector_size / 8.0f;
 
     int sector_x_min = floor((view_position.x - (radar_screen_center.x - rect.position.x) / scale) / sector_size) + 1;
     int sector_x_max = floor((view_position.x + (rect.position.x + rect.size.x - radar_screen_center.x) / scale) / sector_size);
@@ -352,12 +348,12 @@ void GuiRadarView::drawSectorGrid(sp::RenderTarget& renderer)
     for(int sector_x = sector_x_min; sector_x <= sector_x_max; sector_x++)
     {
         float x = sector_x * sector_size;
-        renderer.drawLine(worldToScreen(glm::vec2(x, (sector_y_min-1)*sector_size)), worldToScreen(glm::vec2(x, (sector_y_max+1)*sector_size)), color);
+        renderer.drawLine(worldToScreen(glm::vec2(x, (sector_y_min-1)*sector_size)), worldToScreen(glm::vec2(x, (sector_y_max+1)*sector_size)), 1.0f, color);
     }
     for(int sector_y = sector_y_min; sector_y <= sector_y_max; sector_y++)
     {
         float y = sector_y * sector_size;
-        renderer.drawLine(worldToScreen(glm::vec2((sector_x_min-1)*sector_size, y)), worldToScreen(glm::vec2((sector_x_max+1)*sector_size, y)), color);
+        renderer.drawLine(worldToScreen(glm::vec2((sector_x_min-1)*sector_size, y)), worldToScreen(glm::vec2((sector_x_max+1)*sector_size, y)), 1.0f, color);
     }
 
     color = glm::u8vec4(64, 64, 128, 255);
@@ -475,7 +471,7 @@ void GuiRadarView::drawRangeIndicators(sp::RenderTarget& renderer)
     for(float circle_size=range_indicator_step_size; circle_size < distance; circle_size+=range_indicator_step_size)
     {
         float s = circle_size * scale;
-        renderer.drawCircleOutline(radar_screen_center, s, 2.0, glm::u8vec4(255, 255, 255, 16));
+        renderer.drawCircleOutline(radar_screen_center, s, 3.0, glm::u8vec4(255, 255, 255, 16));
         renderer.drawText(sp::Rect(radar_screen_center.x, radar_screen_center.y - s - 20, 0, 0), string(int(circle_size / 1000.0f + 0.1f)) + DISTANCE_UNIT_1K, sp::Alignment::Center, 20, bold_font, glm::u8vec4(255, 255, 255, 32));
     }
 }
@@ -532,7 +528,7 @@ void GuiRadarView::drawTargetProjections(sp::RenderTarget& renderer)
                     missile_path.push_back(worldToScreen(fire_position + (turn_center + vec2FromAngle(fire_angle - angle_diff / 10.0f * cnt - left_or_right) * turn_radius)));
                 missile_path.push_back(worldToScreen(fire_position + turn_exit));
                 missile_path.push_back(worldToScreen(fire_position + (turn_exit + vec2FromAngle(missile_target_angle) * length_after_turn)));
-                renderer.drawLine(missile_path, glm::u8vec4(255, 255, 255, 128));
+                renderer.drawLine(missile_path, 1.0f, glm::u8vec4(255, 255, 255, 128));
 
                 float offset = seconds_per_distance_tick * data.speed;
                 for(int cnt=0; cnt<floor(data.lifetime / seconds_per_distance_tick); cnt++)
@@ -550,7 +546,7 @@ void GuiRadarView::drawTargetProjections(sp::RenderTarget& renderer)
                     n = rotateVec2(n, -view_rotation);
                     n = glm::normalize(n);
 
-                    renderer.drawLine(p - glm::vec2(n.x, n.y) * 10.0f, p + glm::vec2(n.x, n.y) * 10.0f, glm::u8vec4{255,255,255,255});
+                    renderer.drawLine(p - glm::vec2(n.x, n.y) * 10.0f, p + glm::vec2(n.x, n.y) * 10.0f, 2.0f, glm::u8vec4{255,255,255,255});
 
                     offset += seconds_per_distance_tick * data.speed;
                 }
@@ -570,12 +566,12 @@ void GuiRadarView::drawTargetProjections(sp::RenderTarget& renderer)
                 continue;
 
             auto start = worldToScreen(transform->getPosition());
-            renderer.drawLine(start, worldToScreen(transform->getPosition() + physics->getVelocity() * 60.0f), glm::u8vec4(255, 255, 255, 128), glm::u8vec4(255, 255, 255, 0));
+            renderer.drawLine(start, worldToScreen(transform->getPosition() + physics->getVelocity() * 60.0f), 2.0f, glm::u8vec4(255, 255, 255, 128), glm::u8vec4(255, 255, 255, 0));
             glm::vec2 n = glm::normalize(rotateVec2(glm::vec2(-physics->getVelocity().y, physics->getVelocity().x), -view_rotation)) * 10.0f;
             for(int cnt=0; cnt<5; cnt++)
             {
                 auto p = rotateVec2(physics->getVelocity() * (seconds_per_distance_tick * (cnt + 1.0f) * scale), -view_rotation);
-                renderer.drawLine(start + p + n, start + p - n, glm::u8vec4(255, 255, 255, 128 - cnt * 20));
+                renderer.drawLine(start + p + n, start + p - n, 2.0f, glm::u8vec4(255, 255, 255, 128 - cnt * 20));
             }
         }
     }
@@ -596,7 +592,7 @@ void GuiRadarView::drawMissileTubes(sp::RenderTarget& renderer)
 
         float fire_angle = transform->getRotation() + mount.direction - view_rotation;
 
-        renderer.drawLine(fire_draw_position, fire_draw_position + (vec2FromAngle(fire_angle) * 1000.0f * scale), glm::u8vec4(128, 128, 128, 128), glm::u8vec4(128, 128, 128, 0));
+        renderer.drawLine(fire_draw_position, fire_draw_position + (vec2FromAngle(fire_angle) * 1000.0f * scale), 2.0f, glm::u8vec4(128, 128, 128, 128), glm::u8vec4(128, 128, 128, 0));
     }
 }
 
@@ -785,15 +781,15 @@ void GuiRadarView::drawHeadingIndicators(sp::RenderTarget& renderer)
         renderer.drawLine(
             radar_screen_center + vec2FromAngle(float(n) - 90 - view_rotation) * (scale - 20),
             radar_screen_center + vec2FromAngle(float(n) - 90 - view_rotation) * (scale - 40),
-            {255, 255, 255, 255});
+            2.0f, {255, 255, 255, 255});
     }
 
     for(unsigned int n = 0; n < 360; n += small_tig_interval)
     {
         renderer.drawLine(
             radar_screen_center + vec2FromAngle(float(n) - 90 - view_rotation) * (scale - 20),
             radar_screen_center + vec2FromAngle(float(n) - 90 - view_rotation) * (scale - 30),
-            {255, 255, 255, 255});
+            1.0f, {255, 255, 255, 255});
     }
 
     for(unsigned int n = 0; n < 360; n += tig_interval)

src/screenComponents/rawScannerDataRadarOverlay.cpp

@@ -166,7 +166,7 @@ void RawScannerDataRadarOverlay::onDraw(sp::RenderTarget& renderer)
     a_b.push_back(a_b.front());
 
     // Draw each band as a line.
-    renderer.drawLineBlendAdd(a_r, glm::u8vec4(255, 45, 84, 255)); // red
-    renderer.drawLineBlendAdd(a_g, glm::u8vec4(65, 255, 81, 255)); // green
-    renderer.drawLineBlendAdd(a_b, glm::u8vec4(70, 120, 255, 255)); // blue
+    renderer.drawLineBlendAdd(a_r, 1.0f, glm::u8vec4(255, 45, 84, 255)); // red
+    renderer.drawLineBlendAdd(a_g, 1.0f, glm::u8vec4(65, 255, 81, 255)); // green
+    renderer.drawLineBlendAdd(a_b, 1.0f, glm::u8vec4(70, 120, 255, 255)); // blue
 }

src/screenComponents/signalQualityIndicator.cpp

@@ -48,7 +48,7 @@ void GuiSignalQualityIndicator::onDraw(sp::RenderTarget& renderer)
         f = (1.0f - noise[2]) * f + noise[2] * random(-1.0, 1.0);
         b.emplace_back(rect.position.x + 4.0f + n * 4, rect.position.y + rect.size.y / 2.0f + f * amp);
     }
-    renderer.drawLineBlendAdd(r, glm::u8vec4(255, 45, 84, 255)); // red
-    renderer.drawLineBlendAdd(g, glm::u8vec4(65, 255, 81, 255)); // green
-    renderer.drawLineBlendAdd(b, glm::u8vec4(70, 120, 255, 255)); // blue
+    renderer.drawLineBlendAdd(r, 1.0f, glm::u8vec4(255, 45, 84, 255)); // red
+    renderer.drawLineBlendAdd(g, 1.0f, glm::u8vec4(65, 255, 81, 255)); // green
+    renderer.drawLineBlendAdd(b, 1.0f, glm::u8vec4(70, 120, 255, 255)); // blue
 }

src/screens/gm/chatDialog.cpp

@@ -124,7 +124,7 @@ void GameMasterChatDialog::onDraw(sp::RenderTarget& renderer)
         }
 
         if (auto transform = transmitter->target.getComponent<sp::Transform>())
-            renderer.drawLine(rect.center(), radar->worldToScreen(transform->getPosition()), glm::u8vec4(128, 255, 128, 128));
+            renderer.drawLine(rect.center(), radar->worldToScreen(transform->getPosition()), 2.0f, glm::u8vec4(128, 255, 128, 128));
 
         // Hide the use_comms_script button if the comms target can't use it.
         // TODO: Confirm this works if callback is present
@@ -135,7 +135,7 @@ void GameMasterChatDialog::onDraw(sp::RenderTarget& renderer)
     }
 
     if (auto transform = player.getComponent<sp::Transform>())
-        renderer.drawLine(rect.center(), radar->worldToScreen(transform->getPosition()), glm::u8vec4(128, 255, 128, 128));
+        renderer.drawLine(rect.center(), radar->worldToScreen(transform->getPosition()), 2.0f, glm::u8vec4(128, 255, 128, 128));
 }
 
 void GameMasterChatDialog::disableComms(string title)

src/systems/debugrender.cpp

@@ -74,7 +74,7 @@ void DebugRenderSystem::renderOnRadar(sp::RenderTarget& renderer, sp::ecs::Entit
             auto p2 = screen_position - rotateVec2(s0, rotation);
             auto p3 = screen_position - rotateVec2(s1, rotation);
             std::vector<glm::vec2> points{p0, p1, p2, p3, p0};
-            renderer.drawLine(points, {255, 255, 255, 128});
+            renderer.drawLine(points, 1.0f, {255, 255, 255, 128});
         }
         break;
     }

src/systems/gravity.cpp

@@ -78,7 +78,7 @@ void GravitySystem::renderOnRadar(sp::RenderTarget& renderer, sp::ecs::Entity e,
     if (game_server && (component.wormhole_target.x != 0.0f || component.wormhole_target.y != 0.0f))
     {
         if (auto transform = e.getComponent<sp::Transform>())
-            renderer.drawLine(screen_position, screen_position + (component.wormhole_target - transform->getPosition()) * scale, glm::u8vec4(255, 255, 255, 32));
+            renderer.drawLine(screen_position, screen_position + (component.wormhole_target - transform->getPosition()) * scale, 1.0f, glm::u8vec4(255, 255, 255, 32));
     }
     renderer.drawCircleOutline(screen_position, component.range * scale, 2.0, glm::u8vec4(255, 255, 255, 32));
 }

src/systems/zone.cpp

@@ -16,7 +16,7 @@ void ZoneSystem::renderOnRadar(sp::RenderTarget& renderer, sp::ecs::Entity e, gl
     renderer.drawTriangles(outline_points, zone.triangles, glm::u8vec4(zone.color.r, zone.color.g, zone.color.b, 64));
 
     outline_points.push_back(screen_position + rotateVec2(zone.outline[0] * scale, -rotation));
-    renderer.drawLine(outline_points, glm::u8vec4(zone.color.r, zone.color.g, zone.color.b, 128));
+    renderer.drawLine(outline_points, 4.0f, glm::u8vec4(zone.color.r, zone.color.g, zone.color.b, 128));
 
     if (zone.label.length() > 0)
     {