ShaderNodes: Use PreviewValues instead of QImage

src/ShaderNode/Previews/PreviewModel.hpp

@@ -5,7 +5,7 @@
 
 #include <ShaderNode/Enums.hpp>
 
-class QImage;
+class PreviewValues;
 
 class PreviewModel
 {
@@ -13,7 +13,7 @@ class PreviewModel
 		PreviewModel() = default;
 		virtual ~PreviewModel();
 
-		virtual QImage GetImage(InputRole role, std::size_t roleIndex) const = 0;
+		virtual PreviewValues GetPreview(InputRole role, std::size_t roleIndex) const = 0;
 };
 
 #include <ShaderNode/Previews/PreviewModel.inl>

src/ShaderNode/Previews/PreviewValues.cpp

@@ -0,0 +1,95 @@
+#include <ShaderNode/Previews/PreviewValues.hpp>
+#include <QtGui/QImage>
+
+PreviewValues::PreviewValues() :
+PreviewValues(0, 0)
+{
+}
+
+PreviewValues::PreviewValues(std::size_t width, std::size_t height) :
+m_height(height),
+m_width(width)
+{
+	m_values.resize(m_width * m_height); //< RGBA
+}
+
+void PreviewValues::Fill(const Nz::Vector4f& value)
+{
+	std::fill(m_values.begin(), m_values.end(), value);
+}
+
+QImage PreviewValues::GenerateImage() const
+{
+	QImage preview(int(m_width), int(m_height), QImage::Format_RGBA8888);
+
+	Nz::UInt8* ptr = preview.bits();
+
+	const Nz::Vector4f* src = m_values.data();
+	for (std::size_t i = 0; i < m_values.size(); ++i)
+	{
+		for (std::size_t y = 0; y < 4; ++y)
+			*ptr++ = static_cast<Nz::UInt8>(std::clamp((*src)[y] * 0xFF, 0.f, 255.f));
+
+		*src++;
+	}
+
+	return preview;
+}
+
+PreviewValues PreviewValues::Resized(std::size_t newWidth, std::size_t newHeight) const
+{
+	PreviewValues resizedPreview(newWidth, newHeight);
+
+	float xStep = 1.f / newWidth;
+	float yStep = 1.f / newHeight;
+
+	for (std::size_t y = 0; y < newHeight; ++y)
+	{
+		for (std::size_t x = 0; x < newWidth; ++x)
+			resizedPreview(x, y) = Sample(x * xStep, y * yStep);
+	}
+
+	return resizedPreview;
+}
+
+Nz::Vector4f PreviewValues::Sample(float u, float v) const
+{
+	// Bilinear filtering
+	float x = std::clamp(u * m_width, 0.f, m_width - 1.f);
+	float y = std::clamp(v * m_height, 0.f, m_height - 1.f);
+
+	std::size_t iX = static_cast<std::size_t>(x);
+	std::size_t iY = static_cast<std::size_t>(y);
+
+	float dX = x - iX;
+	float dY = y - iY;
+
+	auto ColorAt = [&](std::size_t x, std::size_t y) -> Nz::Vector4f
+	{
+		x = std::min(x, m_width - 1);
+		y = std::min(y, m_height - 1);
+
+		return m_values[y * m_width + x];
+	};
+
+	Nz::Vector4f d00 = ColorAt(iX, iY);
+	Nz::Vector4f d10 = ColorAt(iX + 1, iY);
+	Nz::Vector4f d01 = ColorAt(iX, iY + 1);
+	Nz::Vector4f d11 = ColorAt(iX + 1, iY + 1);
+
+	return Nz::Lerp(Nz::Lerp(d00, d10, dX), Nz::Lerp(d01, d11, dX), dY);
+}
+
+Nz::Vector4f& PreviewValues::operator()(std::size_t x, std::size_t y)
+{
+	assert(x < m_width);
+	assert(y < m_height);
+	return m_values[y * m_width + x];
+}
+
+Nz::Vector4f PreviewValues::operator()(std::size_t x, std::size_t y) const
+{
+	assert(x < m_width);
+	assert(y < m_height);
+	return m_values[y * m_width + x];
+}

src/ShaderNode/Previews/PreviewValues.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#ifndef NAZARA_SHADERNODES_PREVIEWVALUES_HPP
+#define NAZARA_SHADERNODES_PREVIEWVALUES_HPP
+
+#include <Nazara/Prerequisites.hpp>
+#include <Nazara/Math/Vector4.hpp>
+#include <ShaderNode/Enums.hpp>
+#include <array>
+#include <vector>
+
+class QImage;
+
+class PreviewValues
+{
+	public:
+		PreviewValues();
+		PreviewValues(std::size_t width, std::size_t height);
+		PreviewValues(const PreviewValues&) = default;
+		PreviewValues(PreviewValues&&) = default;
+		~PreviewValues() = default;
+
+		void Fill(const Nz::Vector4f& value);
+
+		QImage GenerateImage() const;
+
+		inline Nz::Vector4f* GetData();
+		inline const Nz::Vector4f* GetData() const;
+		inline std::size_t GetHeight() const;
+		inline std::size_t GetWidth() const;
+
+		PreviewValues Resized(std::size_t newWidth, std::size_t newHeight) const;
+
+		Nz::Vector4f Sample(float u, float v) const;
+
+		Nz::Vector4f& operator()(std::size_t x, std::size_t y);
+		Nz::Vector4f operator()(std::size_t x, std::size_t y) const;
+
+		PreviewValues& operator=(const PreviewValues&) = default;
+		PreviewValues& operator=(PreviewValues&&) = default;
+
+	private:
+		std::size_t m_height;
+		std::size_t m_width;
+		std::vector<Nz::Vector4f> m_values;
+};
+
+#include <ShaderNode/Previews/PreviewValues.inl>
+
+#endif

src/ShaderNode/Previews/PreviewValues.inl

@@ -0,0 +1,21 @@
+#include <ShaderNode/Previews/PreviewValues.hpp>
+
+inline Nz::Vector4f* PreviewValues::GetData()
+{
+	return m_values.data();
+}
+
+inline const Nz::Vector4f* PreviewValues::GetData() const
+{
+	return m_values.data();
+}
+
+inline std::size_t PreviewValues::GetHeight() const
+{
+	return m_width;
+}
+
+inline std::size_t PreviewValues::GetWidth() const
+{
+	return m_height;
+}

src/ShaderNode/Previews/QuadPreview.cpp

@@ -1,27 +1,22 @@
 #include <ShaderNode/Previews/QuadPreview.hpp>
 #include <cassert>
 
-QImage QuadPreview::GetImage(InputRole role, std::size_t roleIndex) const
+PreviewValues QuadPreview::GetPreview(InputRole role, std::size_t roleIndex) const
 {
 	if (role != InputRole::TexCoord)
 	{
-		QImage dummy(1, 1, QImage::Format_RGBA8888);
-		dummy.fill(QColor::fromRgb(0, 0, 0, 0));
+		PreviewValues dummy(1, 1);
+		dummy(0, 0) = Nz::Vector4f::Zero();
+
 		return dummy;
 	}
 
-	QImage uv(128, 128, QImage::Format_RGBA8888);
+	PreviewValues uv(128, 128);
 
-	std::uint8_t* content = uv.bits();
 	for (std::size_t y = 0; y < 128; ++y)
 	{
 		for (std::size_t x = 0; x < 128; ++x)
-		{
-			*content++ = (x * 255) / 128;
-			*content++ = (y * 255) / 128;
-			*content++ = 0;
-			*content++ = 255;
-		}
+			uv(x, y) = Nz::Vector4f(x / 128.f, y / 128.f, 0.f, 1.f);
 	}
 
 	return uv;

src/ShaderNode/Previews/QuadPreview.hpp

@@ -4,7 +4,7 @@
 #define NAZARA_SHADERNODES_QUADPREVIEW_HPP
 
 #include <ShaderNode/Previews/PreviewModel.hpp>
-#include <QtGui/QImage>
+#include <ShaderNode/Previews/PreviewValues.hpp>
 
 class QuadPreview : public PreviewModel
 {
@@ -12,7 +12,7 @@ class QuadPreview : public PreviewModel
 		QuadPreview() = default;
 		~QuadPreview() = default;
 
-		QImage GetImage(InputRole role, std::size_t roleIndex) const override;
+		PreviewValues GetPreview(InputRole role, std::size_t roleIndex) const override;
 };
 
 #include <ShaderNode/Previews/QuadPreview.inl>