+ $($cards -join "`n")
+
+ "@ | Set-Content "build/$env:GAME-rendering-report.html"
+
+ - name: Upload Rendering Report
+ id: report
+ if: always()
+ uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+ with:
+ path: build/${{ inputs.game }}-rendering-report.html
+ archive: false
+ retention-days: 7
+ if-no-files-found: warn
+
+ # Changes fail pull requests and are warnings on main.
+ - name: Check Rendering Changes
+ if: always()
+ env:
+ CHANGES: ${{ steps.compare.outputs.changes }}
+ MESSAGE: ${{ steps.compare.outputs.message }}
+ REPORT_URL: ${{ steps.report.outputs.artifact-url }}
+ run: |
+ "[Open the $env:GAME rendering report]($env:REPORT_URL)" >> $env:GITHUB_STEP_SUMMARY
+ $level = if (!$env:CHANGES) { 'notice' } elseif ($env:GITHUB_EVENT_NAME -eq 'pull_request') { 'error' } else { 'warning' }
+ "::$level title=$env:GAME rendering::$env:MESSAGE. Report: $env:REPORT_URL"
+ if ($level -eq 'error') { exit 1 }
diff --git a/Tests/Google/Core/CMakeLists.txt b/Tests/Google/Core/CMakeLists.txt
index 68c37d4b96d..c4be45b6eda 100644
--- a/Tests/Google/Core/CMakeLists.txt
+++ b/Tests/Google/Core/CMakeLists.txt
@@ -15,6 +15,17 @@ set(COREI_GOOGLETEST_SRC
Libraries/WWVegas/WWMath/WWMathKeys.h
Libraries/WWVegas/WWMath/WWMathTest.cpp
Libraries/WWVegas/WWMath/WWMathTestCase.h
+ Rendering/EXAMPLE_TEMPORARY_ClearTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_LaserTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_ParticlesTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_Render2DBlendingTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_Render2DShapesTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_Render2DTextureTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_TextTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_TracerTest.cpp
+ Rendering/EXAMPLE_TEMPORARY_TriangleTest.cpp
+ Rendering/RenderingTestFixture.cpp
+ Rendering/RenderingTestFixture.h
)
add_library(corei_googletest INTERFACE)
@@ -26,6 +37,7 @@ target_link_libraries(corei_googletest INTERFACE
depsi_googletest
GTest::gtest
imm32
+ stb
vfw32
winmm
)
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ClearTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ClearTest.cpp
new file mode 100644
index 00000000000..b68150a68e2
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ClearTest.cpp
@@ -0,0 +1,29 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+
+// Clearing the render target fills it with the clear color from corner to corner.
+TEST_F(RenderingTest, Clear)
+{
+ const unsigned int color = 0x102030;
+ clear(color);
+ capture();
+ EXPECT_EQ(pixel(0, 0), color);
+ EXPECT_EQ(pixel(Width - 1, Height - 1), color);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_LaserTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_LaserTest.cpp
new file mode 100644
index 00000000000..6992cc60739
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_LaserTest.cpp
@@ -0,0 +1,58 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/segline.h"
+#include "WW3D2/texture.h"
+
+// Lasers are segmented lines with a glowing texture across their width, which W3DLaserDraw adds to the scene with
+// additive blending, so crossing beams add up.
+TEST_F(RenderingTest, Laser)
+{
+ // Brightest along the middle of the beam, dark at its edges.
+ TextureClass *glow = createTexture(32, 32, [](int x, int) -> unsigned int
+ {
+ const unsigned int brightness = 255 - abs(2 * x - 31) * 255 / 31;
+ return 0xFF000000 | brightness << 16 | brightness << 8 | brightness;
+ });
+
+ // A red beam from west to east and a blue one that crosses it on the way up.
+ Vector3 eastWest[] = {Vector3(-6.0f, 0.0f, 0.0f), Vector3(6.0f, 0.0f, 0.0f)};
+ Vector3 diagonal[] = {Vector3(-5.0f, -3.0f, 0.0f), Vector3(5.0f, 3.0f, 2.0f)};
+ SegmentedLineClass *red = NEW_REF(SegmentedLineClass, ());
+ red->Set_Points(2, eastWest);
+ red->Set_Color(Vector3(1.0f, 0.2f, 0.1f));
+ SegmentedLineClass *blue = NEW_REF(SegmentedLineClass, ());
+ blue->Set_Points(2, diagonal);
+ blue->Set_Color(Vector3(0.2f, 0.4f, 1.0f));
+ for (SegmentedLineClass *laser : {red, blue})
+ {
+ laser->Set_Texture(glow);
+ laser->Set_Shader(ShaderClass::_PresetAdditiveShader);
+ laser->Set_Width(0.8f);
+ }
+
+ render({red, blue});
+ REF_PTR_RELEASE(red);
+ REF_PTR_RELEASE(blue);
+ REF_PTR_RELEASE(glow);
+
+ capture();
+ EXPECT_EQ(pixel(8, 8), 0x000000);
+ EXPECT_NE(pixel(Width / 2, Height / 2), 0x000000);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ParticlesTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ParticlesTest.cpp
new file mode 100644
index 00000000000..82884624766
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_ParticlesTest.cpp
@@ -0,0 +1,76 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/camera.h"
+#include "WW3D2/pointgr.h"
+#include "WW3D2/rinfo.h"
+#include "WW3D2/texture.h"
+#include "WW3D2/ww3d.h"
+#include "WWLib/sharebuf.h"
+
+// Particles are camera facing quads with a soft texture, which W3DParticleSystemManager draws in batches with
+// PointGroupClass and additive blending.
+TEST_F(RenderingTest, Particles)
+{
+ // A round puff that fades out towards its edge.
+ TextureClass *puff = createTexture(32, 32, [](int x, int y) -> unsigned int
+ {
+ const float dx = (x - 15.5f) / 16.0f;
+ const float dy = (y - 15.5f) / 16.0f;
+ const unsigned int brightness = static_cast(255.0f * max(0.0f, 1.0f - sqrtf(dx * dx + dy * dy)));
+ return 0xFF000000 | brightness << 16 | brightness << 8 | brightness;
+ });
+
+ // A ring of particles on the ground that turn from red to yellow and grow, around one in the middle.
+ constexpr int Count = 13;
+ ShareBufferClass *locations = NEW_REF(ShareBufferClass, (Count, "ParticlesTest"));
+ ShareBufferClass *colors = NEW_REF(ShareBufferClass, (Count, "ParticlesTest"));
+ ShareBufferClass *sizes = NEW_REF(ShareBufferClass, (Count, "ParticlesTest"));
+ for (int i = 0; i < Count; ++i)
+ {
+ const float angle = i * WWMATH_PI * 2.0f / (Count - 1);
+ const float radius = i == 0 ? 0.0f : 4.0f;
+ locations->Get_Array()[i] = Vector3(radius * cosf(angle), radius * sinf(angle), 0.0f);
+ colors->Get_Array()[i] = Vector4(1.0f, static_cast(i) / Count, 0.1f, 1.0f);
+ sizes->Get_Array()[i] = 1.0f + i * 0.1f;
+ }
+
+ // Set up as W3DParticleSystemManager sets up its batches.
+ PointGroupClass particles;
+ particles.Set_Texture(puff);
+ particles.Set_Shader(ShaderClass::_PresetAdditiveSpriteShader);
+ particles.Set_Flag(PointGroupClass::TRANSFORM, true);
+ particles.Set_Point_Mode(PointGroupClass::QUADS);
+ particles.Set_Billboard(true);
+ particles.Set_Arrays(locations, colors, nullptr, sizes, nullptr, nullptr, Count);
+
+ // The game draws particles from its scene, so this renders them as WW3D::Render renders a scene.
+ RenderInfoClass rinfo(*s_camera);
+ s_camera->Apply();
+ particles.Render(rinfo);
+ WW3D::Flush(rinfo);
+ REF_PTR_RELEASE(locations);
+ REF_PTR_RELEASE(colors);
+ REF_PTR_RELEASE(sizes);
+ REF_PTR_RELEASE(puff);
+
+ capture();
+ EXPECT_EQ(pixel(8, 8), 0x000000);
+ EXPECT_NE(pixel(Width / 2, Height / 2), 0x000000);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DBlendingTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DBlendingTest.cpp
new file mode 100644
index 00000000000..0dbd8af4ee4
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DBlendingTest.cpp
@@ -0,0 +1,56 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/render2d.h"
+
+// The UI and the effects blend over what is below them: alpha fades windows in, additive blending makes glows and
+// multiplicative blending darkens for shadows.
+TEST_F(RenderingTest, Render2DBlending)
+{
+ const unsigned int background = 0x808080;
+ clear(background);
+ Render2DClass renderer;
+ renderer.Set_Coordinate_Range(RectClass(0.0f, 0.0f, Width, Height));
+ renderer.Enable_Texturing(false);
+
+ // Half transparent red.
+ renderer.Enable_Alpha(true);
+ renderer.Add_Quad(RectClass(16.0f, 16.0f, 112.0f, 240.0f), 0x80FF0000);
+ renderer.Render();
+
+ // Green added on top, partly over the red.
+ renderer.Reset();
+ renderer.Enable_Additive(true);
+ renderer.Add_Quad(RectClass(80.0f, 16.0f, 176.0f, 240.0f), 0xFF006000);
+ renderer.Render();
+
+ // Blue multiplied with what is below, partly over the green.
+ renderer.Reset();
+ *renderer.Get_Shader() = ShaderClass::_PresetMultiplicative2DShader;
+ renderer.Enable_Texturing(false);
+ renderer.Add_Quad(RectClass(144.0f, 16.0f, 240.0f, 240.0f), 0xFF4080FF);
+ renderer.Render();
+
+ capture();
+ // The exact blended colors depend on how the GPU rounds, so they are left to the image comparison of CI.
+ EXPECT_EQ(pixel(8, 8), background);
+ EXPECT_NE(pixel(48, 128), background);
+ EXPECT_NE(pixel(128, 128), background);
+ EXPECT_NE(pixel(208, 128), background);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DShapesTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DShapesTest.cpp
new file mode 100644
index 00000000000..7d2163d1eb3
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DShapesTest.cpp
@@ -0,0 +1,43 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/render2d.h"
+
+// The UI draws filled and outlined rectangles, lines and gradients with Render2DClass, as W3DDisplay::drawFillRect
+// and its siblings do.
+TEST_F(RenderingTest, Render2DShapes)
+{
+ Render2DClass renderer;
+ renderer.Set_Coordinate_Range(RectClass(0.0f, 0.0f, Width, Height));
+ renderer.Enable_Texturing(false);
+
+ // A blue rectangle with a white border, an orange outline, a green line and a red to blue gradient.
+ renderer.Add_Rect(RectClass(16.0f, 16.0f, 112.0f, 112.0f), 4.0f, 0xFFFFFFFF, 0xFF2040C0);
+ renderer.Add_Outline(RectClass(144.0f, 16.0f, 240.0f, 112.0f), 2.0f, 0xFFFFC000);
+ renderer.Add_Line(Vector2(16.0f, 136.0f), Vector2(240.0f, 184.0f), 3.0f, 0xFF40FF40);
+ renderer.Add_Quad_HGradient(RectClass(16.0f, 208.0f, 240.0f, 240.0f), 0xFFFF0000, 0xFF0000FF);
+ renderer.Render();
+
+ capture();
+ // The fill and the border of the rectangle, and the inside and the edge of the outline.
+ EXPECT_EQ(pixel(64, 64), 0x2040C0);
+ EXPECT_EQ(pixel(17, 64), 0xFFFFFF);
+ EXPECT_EQ(pixel(192, 64), 0x000000);
+ EXPECT_EQ(pixel(145, 64), 0xFFC000);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DTextureTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DTextureTest.cpp
new file mode 100644
index 00000000000..f1899f6fb9b
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_Render2DTextureTest.cpp
@@ -0,0 +1,60 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/render2d.h"
+#include "WW3D2/texture.h"
+
+// The UI draws its images as textured quads with Render2DClass. Scaled up, point filtering keeps the texels sharp while
+// linear filtering blends them, and transparent texels let the background show through.
+TEST_F(RenderingTest, Render2DTexture)
+{
+ const unsigned int background = 0x204060;
+ clear(background);
+
+ // A red and white checkerboard with a transparent top left quarter.
+ const auto checkerboard = [](int x, int y) -> unsigned int
+ {
+ const unsigned int alpha = (x < 4 && y < 4) ? 0x00000000 : 0xFF000000;
+ return alpha | (((x ^ y) & 1) ? 0xFFFFFF : 0xC02020);
+ };
+ TextureClass *sharp = createTexture(8, 8, checkerboard);
+ sharp->Get_Filter().Set_Min_Filter(TextureFilterClass::FILTER_TYPE_NONE);
+ sharp->Get_Filter().Set_Mag_Filter(TextureFilterClass::FILTER_TYPE_NONE);
+ TextureClass *smooth = createTexture(8, 8, checkerboard);
+ smooth->Get_Filter().Set_Min_Filter(TextureFilterClass::FILTER_TYPE_FAST);
+ smooth->Get_Filter().Set_Mag_Filter(TextureFilterClass::FILTER_TYPE_FAST);
+
+ // The sharp image on the left and the smooth one on the right, both scaled from 8 to 96 pixels.
+ Render2DClass renderer(sharp);
+ renderer.Set_Coordinate_Range(RectClass(0.0f, 0.0f, Width, Height));
+ renderer.Add_Quad(RectClass(16.0f, 64.0f, 112.0f, 160.0f));
+ renderer.Render();
+ renderer.Reset();
+ renderer.Set_Texture(smooth);
+ renderer.Add_Quad(RectClass(144.0f, 64.0f, 240.0f, 160.0f));
+ renderer.Render();
+ REF_PTR_RELEASE(sharp);
+ REF_PTR_RELEASE(smooth);
+
+ capture();
+ // Each texel covers 12 by 12 pixels. These are the centers of texel (5, 5), which is red, and texel (1, 1),
+ // which is transparent.
+ EXPECT_EQ(pixel(16 + 5 * 12 + 6, 64 + 5 * 12 + 6), 0xC02020);
+ EXPECT_EQ(pixel(16 + 1 * 12 + 6, 64 + 1 * 12 + 6), background);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TextTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TextTest.cpp
new file mode 100644
index 00000000000..565f42fd2a1
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TextTest.cpp
@@ -0,0 +1,54 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/render2dsentence.h"
+
+// The UI draws its text with Render2DSentenceClass from glyphs that GDI renders, as W3DDisplayString does,
+// including the drop shadow below the text.
+TEST_F(RenderingTest, Text)
+{
+ const unsigned int background = 0x204060;
+ clear(background);
+
+ FontCharsClass *font = NEW_REF(FontCharsClass, ());
+ ASSERT_TRUE(font->Initialize_GDI_Font("Arial", 16, true));
+ Render2DSentenceClass sentence;
+ sentence.Set_Font(font);
+ REF_PTR_RELEASE(font);
+
+ // The black shadow first, then the text over it.
+ const WCHAR *text = L"Command & Conquer";
+ sentence.Build_Sentence(text, nullptr, nullptr);
+ sentence.Set_Location(Vector2(18.0f, 18.0f));
+ sentence.Draw_Sentence(0xFF000000);
+ sentence.Set_Location(Vector2(16.0f, 16.0f));
+ sentence.Draw_Sentence(0xFFFFC000);
+ sentence.Render();
+ const Vector2 extents = sentence.Get_Text_Extents(text);
+
+ capture();
+ EXPECT_GT(extents.X, 100.0f);
+ // GDI and its fonts differ between systems, so only some text color is expected in the middle row of the text.
+ bool found = false;
+ for (int x = 16; x < 16 + extents.X; ++x)
+ {
+ found |= pixel(x, 16 + static_cast(extents.Y) / 2) == 0xFFC000;
+ }
+ EXPECT_TRUE(found);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TracerTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TracerTest.cpp
new file mode 100644
index 00000000000..5373116f34f
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TracerTest.cpp
@@ -0,0 +1,36 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/line3d.h"
+
+// Tracers are 3D lines, which W3DTracerDraw fades out by lowering their opacity.
+TEST_F(RenderingTest, Tracer)
+{
+ // A solid yellow tracer, crossed by a red one at half opacity.
+ Line3DClass *solid = NEW_REF(Line3DClass, (Vector3(-6.0f, -2.0f, 0.0f), Vector3(6.0f, 2.0f, 0.0f), 0.2f, 1.0f, 0.9f, 0.2f));
+ Line3DClass *faded = NEW_REF(Line3DClass, (Vector3(-6.0f, 2.0f, 0.0f), Vector3(6.0f, -2.0f, 0.0f), 0.2f, 1.0f, 0.3f, 0.2f, 0.5f));
+
+ render({solid, faded});
+ REF_PTR_RELEASE(solid);
+ REF_PTR_RELEASE(faded);
+
+ capture();
+ EXPECT_EQ(pixel(8, 8), 0x000000);
+ EXPECT_NE(pixel(Width / 2, Height / 2), 0x000000);
+}
diff --git a/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TriangleTest.cpp b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TriangleTest.cpp
new file mode 100644
index 00000000000..3ca84150baa
--- /dev/null
+++ b/Tests/Google/Core/Rendering/EXAMPLE_TEMPORARY_TriangleTest.cpp
@@ -0,0 +1,45 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include "WW3D2/render2d.h"
+
+// A triangle with a red, a green and a blue corner blends the corner colors across its area.
+TEST_F(RenderingTest, Triangle)
+{
+ const unsigned int background = 0x102030;
+ clear(background);
+ Render2DClass renderer;
+ renderer.Set_Coordinate_Range(RectClass(0.0f, 0.0f, Width, Height));
+ renderer.Enable_Texturing(false);
+ // Draws the triangle whichever way round its corners go.
+ renderer.Get_Shader()->Set_Cull_Mode(ShaderClass::CULL_MODE_DISABLE);
+ const Vector2 uv(0.0f, 0.0f);
+ renderer.Add_Tri(Vector2(128.0f, 32.0f), Vector2(224.0f, 224.0f), Vector2(32.0f, 224.0f), uv, uv, uv);
+ // Add_Tri gives all corners one color. The color array is a DynamicVectorClass in Zero Hour and a
+ // SimpleDynVecClass in Generals.
+ auto &colors = renderer.Get_Color_Array();
+ colors[0] = 0xFFFF0000;
+ colors[1] = 0xFF00FF00;
+ colors[2] = 0xFF0000FF;
+ renderer.Render();
+ capture();
+ // GPUs round the blended colors differently, so the exact colors are left to the image comparison of CI.
+ EXPECT_EQ(pixel(8, 8), background);
+ EXPECT_NE(pixel(128, 160), background);
+}
diff --git a/Tests/Google/Core/Rendering/RenderingTestFixture.cpp b/Tests/Google/Core/Rendering/RenderingTestFixture.cpp
new file mode 100644
index 00000000000..559c1391ac5
--- /dev/null
+++ b/Tests/Google/Core/Rendering/RenderingTestFixture.cpp
@@ -0,0 +1,159 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#include "RenderingTestFixture.h"
+#include
+#include
+#include
+
+#include "WW3D2/Renderer.h"
+#include "WW3D2/camera.h"
+#include "WW3D2/dx8wrapper.h"
+#include "WW3D2/scene.h"
+#include "WW3D2/surfaceclass.h"
+#include "WW3D2/texture.h"
+#include "WW3D2/ww3d.h"
+#include "WWMath/wwmath.h"
+
+#ifdef RTS_ZEROHOUR
+static const char ImageFolder[] = "z_RenderTest";
+#else
+static const char ImageFolder[] = "g_RenderTest";
+#endif
+
+CameraClass *RenderingTest::s_camera = nullptr;
+HWND RenderingTest::s_window = nullptr;
+
+void RenderingTest::SetUpTestSuite()
+{
+ // Borderless, so that the window is as large as the back buffer.
+ s_window = CreateWindowA("STATIC", "RenderingTest", WS_POPUP, 0, 0, Width, Height, nullptr, nullptr, GetModuleHandle(nullptr), nullptr);
+ ASSERT_NE(s_window, nullptr);
+ WWMath::Init();
+ ASSERT_EQ(WW3D::Init(s_window), WW3D_ERROR_OK);
+ WW3D::Set_Screen_UV_Bias(TRUE);
+ // Thumbnails need an asset manager.
+ WW3D::Set_Thumbnail_Enabled(false);
+ ASSERT_EQ(WW3D::Set_Render_Device(0, Width, Height, 32, TRUE), WW3D_ERROR_OK);
+
+ s_camera = NEW_REF(CameraClass, ());
+ Matrix3D transform;
+ transform.Look_At(Vector3(0.0f, -12.0f, 6.0f), Vector3(0.0f, 0.0f, 0.0f), 0.0f);
+ s_camera->Set_Transform(transform);
+ s_camera->Set_View_Plane(DEG_TO_RADF(50.0f), DEG_TO_RADF(50.0f));
+ s_camera->Set_Clip_Planes(1.0f, 100.0f);
+
+ std::filesystem::create_directory(ImageFolder);
+}
+
+void RenderingTest::TearDownTestSuite()
+{
+ REF_PTR_RELEASE(s_camera);
+ WW3D::Shutdown();
+ WWMath::Shutdown();
+ if (s_window != nullptr)
+ {
+ DestroyWindow(s_window);
+ s_window = nullptr;
+ }
+}
+
+void RenderingTest::SetUp()
+{
+ ASSERT_EQ(WW3D::Begin_Render(true, true, Vector3(0.0f, 0.0f, 0.0f)), WW3D_ERROR_OK);
+ m_rendering = true;
+}
+
+void RenderingTest::TearDown()
+{
+ if (m_rendering)
+ {
+ WW3D::End_Render(false);
+ }
+}
+
+void RenderingTest::clear(unsigned int color)
+{
+ const Vector3 rgb((color >> 16 & 0xFF) / 255.0f, (color >> 8 & 0xFF) / 255.0f, (color & 0xFF) / 255.0f);
+ Renderer::Clear(true, false, rgb);
+}
+
+void RenderingTest::render(std::initializer_list objects)
+{
+ SimpleSceneClass *scene = NEW_REF(SimpleSceneClass, ());
+ scene->Set_Ambient_Light(Vector3(1.0f, 1.0f, 1.0f));
+ for (RenderObjClass *object : objects)
+ {
+ scene->Add_Render_Object(object);
+ }
+ EXPECT_EQ(WW3D::Render(scene, s_camera), WW3D_ERROR_OK);
+ REF_PTR_RELEASE(scene);
+}
+
+TextureClass *RenderingTest::createTexture(int width, int height, const std::function &color)
+{
+ SurfaceClass *surface = NEW_REF(SurfaceClass, (width, height, WW3D_FORMAT_A8R8G8B8));
+ int pitch = 0;
+ unsigned char *bits = static_cast(surface->Lock(&pitch));
+ for (int y = 0; y < height; ++y)
+ {
+ for (int x = 0; x < width; ++x)
+ {
+ reinterpret_cast(bits + y * pitch)[x] = color(x, y);
+ }
+ }
+ surface->Unlock();
+ TextureClass *texture = NEW_REF(TextureClass, (surface, MIP_LEVELS_1));
+ REF_PTR_RELEASE(surface);
+ return texture;
+}
+
+// DX8 specific until Renderer can read the back buffer.
+void RenderingTest::capture()
+{
+ ASSERT_TRUE(m_rendering);
+ const std::string imageName = (std::filesystem::path(ImageFolder) / ::testing::UnitTest::GetInstance()->current_test_info()->name()).string() + "_" + std::to_string(m_captures++) + ".png";
+ WW3D::End_Render(false);
+ m_rendering = false;
+ SurfaceClass *backBuffer = DX8Wrapper::_Get_DX8_Back_Buffer();
+ ASSERT_NE(backBuffer, nullptr);
+ SurfaceClass *copy = NEW_REF(SurfaceClass, (Width, Height, Renderer::Get_Back_Buffer_Format()));
+ DX8Wrapper::_Copy_DX8_Rects(backBuffer->Peek_D3D_Surface(), nullptr, 0, copy->Peek_D3D_Surface(), nullptr);
+ REF_PTR_RELEASE(backBuffer);
+ int pitch = 0;
+ const unsigned char *bits = static_cast(copy->Lock(&pitch));
+ std::vector rgb;
+ rgb.reserve(Width * Height * 3);
+ for (int y = 0; y < Height; ++y)
+ {
+ const unsigned int *row = reinterpret_cast(bits + y * pitch);
+ for (int x = 0; x < Width; ++x)
+ {
+ const unsigned int color = row[x] & 0x00ffffff;
+ m_pixels[y * Width + x] = color;
+ rgb.push_back(static_cast(color >> 16));
+ rgb.push_back(static_cast(color >> 8));
+ rgb.push_back(static_cast(color));
+ }
+ }
+ copy->Unlock();
+ REF_PTR_RELEASE(copy);
+ EXPECT_NE(stbi_write_png(imageName.c_str(), Width, Height, 3, rgb.data(), Width * 3), 0) << imageName;
+ ASSERT_EQ(WW3D::Begin_Render(true, true, Vector3(0.0f, 0.0f, 0.0f)), WW3D_ERROR_OK);
+ m_rendering = true;
+}
diff --git a/Tests/Google/Core/Rendering/RenderingTestFixture.h b/Tests/Google/Core/Rendering/RenderingTestFixture.h
new file mode 100644
index 00000000000..0a53dc352f5
--- /dev/null
+++ b/Tests/Google/Core/Rendering/RenderingTestFixture.h
@@ -0,0 +1,56 @@
+/*
+** Command & Conquer Generals Zero Hour(tm)
+** Copyright 2026 TheSuperHackers
+**
+** This program is free software: you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation, either version 3 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program. If not, see .
+*/
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+
+class CameraClass;
+class RenderObjClass;
+class TextureClass;
+
+// Each test renders with WW3D into a black frame and captures it for the rendering check of CI.
+class RenderingTest : public ::testing::Test
+{
+protected:
+ static constexpr int Width = 256;
+ static constexpr int Height = 256;
+
+ static void SetUpTestSuite();
+ static void TearDownTestSuite();
+ virtual void SetUp() override;
+ virtual void TearDown() override;
+
+ static void clear(unsigned int color);
+ static void render(std::initializer_list objects);
+ static TextureClass *createTexture(int width, int height, const std::function &color); // color(x, y) returns 0xAARRGGBB.
+ void capture(); // Saves the frame as _.png and starts a new one.
+ unsigned int pixel(int x, int y) const { return m_pixels[y * Width + x]; } // 0xRRGGBB of the last capture.
+
+ static CameraClass *s_camera; // Looks at the origin from the south, with z up.
+
+private:
+ std::vector m_pixels = std::vector(Width * Height);
+ int m_captures = 0;
+ bool m_rendering = false;
+ static HWND s_window;
+};