Reintroduces the accumulation texture.

Disables automatic clearing of the texture target, as the profiler indicates the vector instantiation to be a huge time sink.

OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme

@@ -78,7 +78,6 @@
       ignoresPersistentStateOnLaunch = "NO"
       debugDocumentVersioning = "YES"
       stopOnEveryThreadSanitizerIssue = "YES"
-      stopOnEveryUBSanitizerIssue = "YES"
       debugServiceExtension = "internal"
       allowLocationSimulation = "NO">
       <BuildableProductRunnable

Outputs/OpenGL/Primitives/TextureTarget.cpp

@@ -31,9 +31,8 @@ TextureTarget::TextureTarget(GLsizei width, GLsizei height, GLenum texture_unit,
 	glGenTextures(1, &texture_);
 	bind_texture();
 
-	// Upload a blank initial texture and set the user-supplied magnification filter.
-	std::vector<uint8_t> blank_buffer(static_cast<size_t>(expanded_width_ * expanded_height_ * 4), 0);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, static_cast<GLsizei>(expanded_width_), static_cast<GLsizei>(expanded_height_), 0, GL_RGBA, GL_UNSIGNED_BYTE, blank_buffer.data());
+	// Set dimensions and set the user-supplied magnification filter.
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, static_cast<GLsizei>(expanded_width_), static_cast<GLsizei>(expanded_height_), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 

Outputs/OpenGL/Primitives/TextureTarget.hpp

@@ -24,7 +24,7 @@ namespace OpenGL {
 class TextureTarget {
 	public:
 		/*!
-			Creates a new texture target.
+			Creates a new texture target. Contents are initially undefined.
 
 			Throws ErrorFramebufferIncomplete if creation fails. Leaves both the generated texture and framebuffer bound.
 

Outputs/OpenGL/ScanTarget.cpp

@@ -73,7 +73,8 @@ template <typename T> void ScanTarget::allocate_buffer(const T &array, GLuint &b
 }
 
 ScanTarget::ScanTarget() :
- 	unprocessed_line_texture_(LineBufferWidth, LineBufferHeight, UnprocessedLineBufferTextureUnit, GL_LINEAR, false) {
+ 	unprocessed_line_texture_(LineBufferWidth, LineBufferHeight, UnprocessedLineBufferTextureUnit, GL_LINEAR, false),
+ 	full_display_rectangle_(-1.0f, -1.0f, 2.0f, 2.0f) {
 
 	// Ensure proper initialisation of the two atomic pointer sets.
 	read_pointers_.store(write_pointers_);
@@ -296,6 +297,12 @@ void ScanTarget::announce(Event event, uint16_t x, uint16_t y) {
 			// Commit the most recent line only if any scans fell on it.
 			// Otherwise there's no point outputting it, it'll contribute nothing.
 			if(provided_scans_) {
+				// Store metadata if concluding a previous line.
+				if(active_line_) {
+					line_metadata_buffer_[size_t(write_pointers_.line)].is_first_in_frame = is_first_in_frame_;
+					is_first_in_frame_ = false;
+				}
+
 				const auto read_pointers = read_pointers_.load();
 
 				// Attempt to allocate a new line; note allocation failure if necessary.
@@ -316,6 +323,9 @@ void ScanTarget::announce(Event event, uint16_t x, uint16_t y) {
 				active_line_->line = write_pointers_.line;
 			}
 		} break;
+		case ScanTarget::Event::EndVerticalRetrace:
+			is_first_in_frame_ = true;
+		break;
 	}
 
 	// TODO: any lines that include any portion of vertical sync should be hidden.
@@ -477,10 +487,30 @@ void ScanTarget::draw(bool synchronous, int output_width, int output_height) {
 		glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, GLsizei(new_scans));
 	}
 
-	// Clear the target framebuffer (TODO: don't assume 0).
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	glViewport(0, 0, (GLsizei)output_width, (GLsizei)output_height);
-	glClear(GL_COLOR_BUFFER_BIT);
+	// Ensure the accumulation buffer is properly sized.
+	if(!accumulation_texture_ || (!synchronous && (accumulation_texture_->get_width() != output_width || accumulation_texture_->get_height() != output_height))) {
+		std::unique_ptr<OpenGL::TextureTarget> new_framebuffer(
+			new TextureTarget(
+				GLsizei(output_width),
+				GLsizei(output_height),
+				AccumulationTextureUnit,
+				GL_LINEAR,
+				true));
+		if(accumulation_texture_) {
+			new_framebuffer->bind_framebuffer();
+			glClear(GL_COLOR_BUFFER_BIT);
+
+			glActiveTexture(AccumulationTextureUnit);
+			accumulation_texture_->bind_texture();
+			accumulation_texture_->draw(float(output_width) / float(output_height));
+
+			new_framebuffer->bind_texture();
+		}
+		accumulation_texture_ = std::move(new_framebuffer);
+	}
+
+	// Bind the accumulation texture.
+	accumulation_texture_->bind_framebuffer();
 
 	// Output all lines except the one currently being worked on.
 	glBindVertexArray(line_vertex_array_);
@@ -488,6 +518,15 @@ void ScanTarget::draw(bool synchronous, int output_width, int output_height) {
 	glEnable(GL_BLEND);
 	glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, GLsizei(line_buffer_.size() - 2));
 
+	// Copy the accumulatiion texture to the target (TODO: don't assume framebuffer 0).
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glViewport(0, 0, (GLsizei)output_width, (GLsizei)output_height);
+
+	glDisable(GL_BLEND);
+	glClear(GL_COLOR_BUFFER_BIT);
+	accumulation_texture_->bind_texture();
+	accumulation_texture_->draw(float(output_width) / float(output_height), 4.0f / 255.0f);
+
 	// All data now having been spooled to the GPU, update the read pointers to
 	// the submit pointer location.
 	read_pointers_.store(submit_pointers);

Outputs/OpenGL/ScanTarget.hpp

@@ -12,6 +12,7 @@
 #include "../ScanTarget.hpp"
 #include "OpenGL.hpp"
 #include "Primitives/TextureTarget.hpp"
+#include "Primitives/Rectangle.hpp"
 
 #include <array>
 #include <atomic>
@@ -77,17 +78,35 @@ class ScanTarget: public Outputs::Display::ScanTarget {
 		// Maintains a buffer of the most recent 3072 scans.
 		std::array<Scan, 3072> scan_buffer_;
 
-		// Maintains a list of composite scan buffer coordinates.
+		// Maintains a list of composite scan buffer coordinates; the Line struct
+		// is transported to the GPU in its entirety; the LineMetadatas live in CPU
+		// space only.
 		struct Line {
 			struct EndPoint {
 				uint16_t x, y;
 			} end_points[2];
 			uint16_t line;
 		};
+		struct LineMetadata {
+			bool is_first_in_frame;
+		};
 		std::array<Line, LineBufferHeight> line_buffer_;
+		std::array<LineMetadata, LineBufferHeight> line_metadata_buffer_;
+
+		// Contains the first composition of scans into lines;
+		// they're accumulated prior to output to allow for continuous
+		// application of any necessary conversions — e.g. composite processing.
 		TextureTarget unprocessed_line_texture_;
+
+		// Scans are accumulated to the accumulation texture; the full-display
+		// rectangle is used to ensure untouched pixels properly decay.
+		std::unique_ptr<TextureTarget> accumulation_texture_;
+		Rectangle full_display_rectangle_;
+
+		// Ephemeral state that helps in line composition.
 		Line *active_line_ = nullptr;
 		int provided_scans_ = 0;
+		bool is_first_in_frame_ = true;
 
 		// OpenGL storage handles for buffer data.
 		GLuint scan_buffer_name_ = 0, scan_vertex_array_ = 0;