Files
AVA2/tests/hardware_scene_test.cpp
T
shenleiandClaude Opus 5.5 5de09d07e9 Sort blended draws by bounds centre instead of first vertex
Back-to-front order for blended, non-depth-writing, water and additive
draws now uses the bounds centre of the vertices the draw indexes. The
centre of shared (immutable) geometry is cached per index range and
validated against the owning pointer; per-frame geometry is recomputed.
Depth-writing opaque draws keep the first-vertex tie-break.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 18:09:31 +09:00

251 lines
18 KiB
C++

#ifdef NDEBUG
#undef NDEBUG
#endif
#include "eter_render/HardwareScene.h"
#include "eter_render/Gr2ModelRenderer.h"
#include "eter_render/RenderCommands3D.h"
#include "eter_ui/Font.h"
#include <SDL3/SDL.h>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <array>
#include <memory>
#include <algorithm>
#include <filesystem>
#include <fstream>
int main() {
{ // Referenced (cached) commands splice in before owned[before], in submission order.
std::vector<ava2::Render3DDraw> owned(3);ava2::Render3DDraw cachedA,cachedB,cachedC;
std::vector<ava2::Render3DDrawRef> refs{{1,&cachedA},{1,&cachedB},{3,&cachedC}};
std::vector<const ava2::Render3DDraw*> list;ava2::FlattenDraws(owned,refs,list);
const std::vector<const ava2::Render3DDraw*> expect{&owned[0],&cachedA,&cachedB,&owned[1],&owned[2],&cachedC};
assert(list==expect);
}
if(!SDL_Init(SDL_INIT_VIDEO))return 77;
auto* device=SDL_CreateGPUDevice(SDL_GPU_SHADERFORMAT_MSL|SDL_GPU_SHADERFORMAT_SPIRV,true,nullptr);
if(!device){SDL_Quit();return 77;}
auto* window=SDL_CreateWindow("AVA2 depth verification",64,64,0);
auto* renderer=window ? SDL_CreateGPURenderer(device,window) : nullptr;
if(!renderer){if(window)SDL_DestroyWindow(window);SDL_DestroyGPUDevice(device);SDL_Quit();return 77;}
SDL_SetRenderVSync(renderer,0);
SDL_SetRenderLogicalPresentation(renderer,64,64,SDL_LOGICAL_PRESENTATION_LETTERBOX);
{
ava2::HardwareScene scene(device);
std::vector<ava2::HardwareVertex> vertices;
auto triangle=[&](float z,float r,float g,float b,float alpha) {
for(auto p: {std::pair{-0.9f,-0.9f},std::pair{0.9f,-0.9f},std::pair{0.f,0.9f}})
vertices.push_back({{p.first,p.second,z,1},{uint8_t(r*255),uint8_t(g*255),uint8_t(b*255),uint8_t(alpha*255)},{0,0}});
};
triangle(.2,1,0,0,1);triangle(.8,0,1,0,1);triangle(.1,0,0,1,.2);
std::vector<uint32_t> indices{0,1,2,3,4,5,6,7,8};
ava2::HardwareBatch near{0,3,nullptr,1,true,true,false,false,-1};
auto far=near;far.firstIndex=3;
auto masked=near;masked.firstIndex=6;masked.alphaRef=.5;
auto center=[&](std::vector<ava2::HardwareBatch> batches) {
SDL_SetRenderDrawColor(renderer,0,255,0,255);SDL_RenderClear(renderer);
assert(scene.Render(renderer,64,64,vertices,indices,batches));
SDL_Surface* result=SDL_RenderReadPixels(renderer,nullptr);assert(result);
Uint8 r,g,b,a;Uint32 pixel=0;
std::memcpy(&pixel,static_cast<Uint8*>(result->pixels)+(result->h/2)*result->pitch+(result->w/2)*SDL_BYTESPERPIXEL(result->format),SDL_BYTESPERPIXEL(result->format));
SDL_GetRGBA(pixel,SDL_GetPixelFormatDetails(result->format),nullptr,&r,&g,&b,&a);
Uint32 corner=0;std::memcpy(&corner,result->pixels,SDL_BYTESPERPIXEL(result->format));
Uint8 cr,cg,cb,ca;SDL_GetRGBA(corner,SDL_GetPixelFormatDetails(result->format),nullptr,&cr,&cg,&cb,&ca);
assert(cg>245&&cr<5&&cb<5); // preserve the 2D character selection background
SDL_DestroySurface(result);SDL_RenderPresent(renderer);
return std::array<int,3>{r,g,b};
};
// Later far geometry must not overwrite nearer pixels (old painter rendering did).
auto color=center({near,far});assert(color[0]>245&&color[1]<5);
color=center({near,far,masked});assert(color[0]>245&&color[2]<5);
masked.alphaRef=-1; // opaque DDS alpha is specular, not transparency
color=center({near,masked});assert(color[2]>245&&color[0]<5);
near.depthWrite=false;color=center({near,far});assert(color[1]>245&&color[0]<5);
near.depthWrite=true;near.cull=2;color=center({near});assert(color[0]>245);
// Perspective-correct color interpolation: top W=2 doubles its reciprocal denominator.
auto saved=vertices;
vertices[2].position[1]*=2;vertices[2].position[2]*=2;vertices[2].position[3]=2;
vertices[0].color[0]=vertices[1].color[0]=0;vertices[2].color[0]=255;
near.cull=1;color=center({near});assert(color[0]>65&&color[0]<100);
vertices=saved;
// Newly uploaded textures must be usable on their first frame, even
// while SDL still has a pending 2D command buffer.
const Uint8 texel[4]={255,255,255,40};
masked.texture=scene.Texture("first-frame-alpha",1,1,texel);assert(masked.texture);
masked.alphaRef=.5f;near.cull=1;
color=center({near,masked});assert(color[0]>245&&color[2]<5);
masked.alphaRef=-1;color=center({near,masked});assert(color[2]>245&&color[0]<5);
// Text is reused across repeated labels, recolored, and cleaned up with each renderer.
for(int i=0;i<100;++i)UI::DrawText(renderer,"NPC label",12,0,0,i%2 ? 0xffff0000 : 0xff00ff00);
assert(SDL_RenderPresent(renderer));
}
{ // Render scale < 1: a smaller colour target is upscaled over the whole render target in the composite.
ava2::HardwareScene scaled(device);
std::vector<ava2::HardwareVertex> quad;
for(auto p: {std::pair{-1.f,-1.f},std::pair{1.f,-1.f},std::pair{1.f,1.f},std::pair{-1.f,1.f}})
quad.push_back({{p.first,p.second,.5f,1},{255,0,0,255},{0,0}});
SDL_SetRenderDrawColor(renderer,0,255,0,255);SDL_RenderClear(renderer);
assert(scaled.Render(renderer,32,32,quad,{0,1,2,0,2,3},{{0,6,nullptr,1,true,true,false,false,-1}}));
auto* pixels=SDL_RenderReadPixels(renderer,nullptr);assert(pixels);
auto redAt=[&](int x,int y){Uint32 v=0;std::memcpy(&v,static_cast<Uint8*>(pixels->pixels)+y*pixels->pitch+x*SDL_BYTESPERPIXEL(pixels->format),SDL_BYTESPERPIXEL(pixels->format));
Uint8 r,g,b,a;SDL_GetRGBA(v,SDL_GetPixelFormatDetails(pixels->format),nullptr,&r,&g,&b,&a);return r>245&&g<5;};
assert(redAt(1,1)&&redAt(62,62)&&redAt(62,1)&&redAt(1,62)&&redAt(32,32));
SDL_DestroySurface(pixels);SDL_RenderPresent(renderer);
}
{
ava2::Gr2SceneRenderer raster(64,64);
raster.SetGPUDevice(device);
raster.SetViewport(0,0,64,64);
raster.SetCameraLookAt(0,0,-2,0,0,0,0,1,0);
raster.SetPerspective(60,1,.1f,100);
ava2::Render3DDraw draw;
draw.positions={-.9f,-.9f,0,.9f,-.9f,0,0,.9f,0};
draw.indices={0,1,2};draw.diffuse={0xffff0000,0xffff0000,0xffff0000};
draw.lighting=false;draw.fog=false;draw.cull_mode=1;
auto readCenter=[&](const ava2::Render3DDraw& command) {
SDL_SetRenderDrawColor(renderer,0,0,0,255);SDL_RenderClear(renderer);
raster.RenderSceneGPU(renderer,{command});
auto* surface=SDL_RenderReadPixels(renderer,nullptr);assert(surface);
Uint32 pixel;std::memcpy(&pixel,static_cast<Uint8*>(surface->pixels)+32*surface->pitch+32*SDL_BYTESPERPIXEL(surface->format),SDL_BYTESPERPIXEL(surface->format));
Uint8 r,g,b,a;SDL_GetRGBA(pixel,SDL_GetPixelFormatDetails(surface->format),nullptr,&r,&g,&b,&a);
SDL_DestroySurface(surface);SDL_RenderPresent(renderer);
return std::array<int,3>{r,g,b};
};
const auto original=readCenter(draw);
auto shared=ava2::Render3DDraw::ShareGeometry(std::move(draw));
assert(shared.positions.empty() && shared.geometry);
assert(readCenter(shared)==original && original[0]>245 && original[1]<5);
shared.material_diffuse[0]=.5f;
const auto tinted=readCenter(shared);assert(tinted[0]>120&&tinted[0]<135);
const auto path=std::filesystem::temp_directory_path()/"ava2_scene_texture_budget.dds";
uint32_t header[32]{};header[0]=0x20534444;header[1]=124;header[2]=0x100f;header[3]=2;header[4]=2;header[5]=8;
header[19]=32;header[20]=0x41;header[22]=32;header[23]=0xff;header[24]=0xff00;header[25]=0xff0000;header[26]=0xff000000;header[27]=0x1000;
{std::ofstream file(path,std::ios::binary);file.write(reinterpret_cast<const char*>(header),sizeof(header));uint32_t red[4]={0xff0000ff,0xff0000ff,0xff0000ff,0xff0000ff};file.write(reinterpret_cast<const char*>(red),sizeof(red));}
shared.texture0=path.string();shared.material_diffuse[0]=1;
raster.SetTextureBudgets(0,4);const auto decodes=raster.GetTextureDecodeCount();
assert(readCenter(shared)[0]>245);assert(raster.GetDecodedTextureBytes()==0);
assert(raster.GetTextureDecodeCount()==decodes+1);
assert(readCenter(shared)[0]>245);assert(raster.GetTextureDecodeCount()==decodes+1);
// Switching to CPU raster must reload evicted decoded bytes and preserve the active image.
SDL_Surface* cpu=SDL_CreateSurface(64,64,SDL_PIXELFORMAT_ARGB8888);assert(cpu);
raster.Clear();raster.RenderScene(cpu,{shared});assert(raster.GetTextureDecodeCount()==decodes+2);
assert(raster.GetDecodedTextureBytes()==16);
raster.Clear();raster.RenderScene(cpu,{shared});assert(raster.GetTextureDecodeCount()==decodes+2);
SDL_DestroySurface(cpu);std::filesystem::remove(path);
// Blended draws sort back to front by the bounds centre of their indexed vertices: the far
// blue triangle's unindexed vertex 0 sits right before the eye and must not pull it in front.
ava2::Render3DDraw nearRed;
nearRed.positions={-.9f,-.9f,-.5f,.9f,-.9f,-.5f,0,.9f,-.5f};
nearRed.indices={0,1,2};nearRed.diffuse={0xffff0000,0xffff0000,0xffff0000};
nearRed.lighting=false;nearRed.fog=false;nearRed.cull_mode=1;nearRed.alpha_blend=true;nearRed.z_write=false;
ava2::Render3DDraw farBlue=nearRed;
farBlue.positions={0,0,-1.95f,-2,-2,1,2,-2,1,0,2,1};
farBlue.indices={1,2,3};farBlue.diffuse=std::vector<uint32_t>(4,0xff0000ff);
auto readOrder=[&](const std::vector<ava2::Render3DDraw>& commands) {
SDL_SetRenderDrawColor(renderer,0,0,0,255);SDL_RenderClear(renderer);
raster.RenderSceneGPU(renderer,commands);
auto* surface=SDL_RenderReadPixels(renderer,nullptr);assert(surface);
Uint32 pixel;std::memcpy(&pixel,static_cast<Uint8*>(surface->pixels)+32*surface->pitch+32*SDL_BYTESPERPIXEL(surface->format),SDL_BYTESPERPIXEL(surface->format));
Uint8 r,g,b,a;SDL_GetRGBA(pixel,SDL_GetPixelFormatDetails(surface->format),nullptr,&r,&g,&b,&a);
SDL_DestroySurface(surface);SDL_RenderPresent(renderer);
return std::array<int,3>{r,g,b};
};
auto order=readOrder({nearRed,farBlue});assert(order[0]>245&&order[2]<5);
order=readOrder({farBlue,nearRed});assert(order[0]>245&&order[2]<5);
auto sharedBlue=ava2::Render3DDraw::ShareGeometry(farBlue);
for(int frame=0;frame<2;++frame){order=readOrder({nearRed,sharedBlue});assert(order[0]>245&&order[2]<5);}
}
{
ava2::HardwareScene resident(device);
auto mesh=std::make_shared<ava2::Render3DDraw>();
mesh->positions={-.15f,-.2f,.5f,.15f,-.2f,.5f,0,.2f,.5f};mesh->indices={0,1,2};
mesh->diffuse={0xffff0000,0xffff0000,0xffff0000};
ava2::HardwareBatch left{};left.geometry=mesh;left.indexCount=3;left.cull=1;left.depth=true;left.depthWrite=true;left.alphaRef=-1;
for(int k=0;k<16;++k)left.transform.mvp[k]=left.transform.world[k]=(k%5==0) ? 1.f : 0.f;
for(auto& c:left.transform.diffuse)c=1;
left.transform.modes[0]=1;left.transform.mvp[12]=-.5f;
auto right=left;right.transform.mvp[12]=.5f;right.transform.diffuse[0]=.5f;
auto frame=[&](std::vector<ava2::HardwareBatch> batches){
SDL_SetRenderDrawColor(renderer,0,0,0,255);SDL_RenderClear(renderer);
assert(resident.Render(renderer,64,64,{},{},batches));
auto* pixels=SDL_RenderReadPixels(renderer,nullptr);assert(pixels);SDL_RenderPresent(renderer);return pixels;
};
auto* pixels=frame({left,right});
assert(resident.GetResidentUploadCount()==1 && resident.GetLastDynamicUploadBytes()==0 && resident.GetLastDrawCallCount()==1);
auto redAt=[&](int x){Uint32 color;std::memcpy(&color,static_cast<Uint8*>(pixels->pixels)+32*pixels->pitch+x*SDL_BYTESPERPIXEL(pixels->format),SDL_BYTESPERPIXEL(pixels->format));Uint8 r,g,b,a;SDL_GetRGBA(color,SDL_GetPixelFormatDetails(pixels->format),nullptr,&r,&g,&b,&a);return int(r);};
assert(redAt(16)>245 && redAt(48)>120 && redAt(48)<135 && redAt(32)<5);SDL_DestroySurface(pixels);
pixels=frame({left,right});SDL_DestroySurface(pixels);assert(resident.GetResidentUploadCount()==1);
auto offscreen=left;offscreen.blend=true;offscreen.transform.mvp[12]=-5;
pixels=frame({offscreen,left,right});
assert(resident.GetLastDrawCallCount()==2 && redAt(16)>245 && redAt(48)>120 && redAt(48)<135);
SDL_DestroySurface(pixels);
// Tri-group sub-ranges share one resident buffer; firstIndex selects the right-hand triangle only.
{
auto groups=std::make_shared<ava2::Render3DDraw>(*mesh);
groups->positions={-.65f,-.2f,.5f,-.35f,-.2f,.5f,-.5f,.2f,.5f, .35f,-.2f,.5f,.65f,-.2f,.5f,.5f,.2f,.5f};
groups->indices={0,1,2,3,4,5};groups->diffuse=std::vector<uint32_t>(6,0xffff0000);
auto second=left;second.geometry=groups;second.transform.mvp[12]=0;second.firstIndex=3;second.indexCount=3;
const auto uploads=resident.GetResidentUploadCount();
pixels=frame({second});
assert(resident.GetResidentUploadCount()==uploads+1 && resident.GetLastDynamicUploadBytes()==0);
assert(redAt(48)>245 && redAt(16)<5);SDL_DestroySurface(pixels);
auto first=second;first.firstIndex=0;
pixels=frame({first,second});
assert(resident.GetResidentUploadCount()==uploads+1 && resident.GetLastDrawCallCount()==2);
assert(redAt(16)>245 && redAt(48)>245);SDL_DestroySurface(pixels);
}
// Bone translation moves the raw triangle to the center; no CPU-deformed stream is uploaded.
left.transform.skin[0]=1;left.palette=std::make_shared<std::vector<float>>(std::vector<float>{1,0,0,0,0,1,0,0,0,0,1,0,.5f,0,0,1});
auto skinned=std::make_shared<ava2::Render3DDraw>(*mesh);skinned->bone_indices=std::vector<uint8_t>(12,0);skinned->bone_weights={1,0,0,0,1,0,0,0,1,0,0,0};left.geometry=skinned;
pixels=frame({left});assert(redAt(32)>245 && redAt(16)<5);SDL_DestroySurface(pixels);
// Two weighted, rotated bones: compare every rendered pixel to CPU-transformed vertices.
left.transform.skin[0]=2;
left.palette=std::make_shared<std::vector<float>>(std::vector<float>{1,0,0,0,0,1,0,0,0,0,1,0,.2f,0,0,1,
0,1,0,0,-1,0,0,0,0,0,1,0,.7f,0,0,1});
skinned=std::make_shared<ava2::Render3DDraw>(*mesh);
skinned->bone_indices={0,1,0,0,0,1,0,0,0,1,0,0};
skinned->bone_weights={.4f,.6f,0,0,.4f,.6f,0,0,.4f,.6f,0,0};
left.geometry=skinned;pixels=frame({left});
std::vector<ava2::HardwareVertex> reference;
for(size_t v=0;v<3;++v){auto vertex=ava2::MakeHardwareVertex(*skinned,v);float pos[4]{};
for(size_t b=0;b<2;++b){const auto* matrix=left.palette->data()+b*16;float w=vertex.weights[b]/65535.f;
for(int k=0;k<4;++k)pos[k]+=(vertex.position[0]*matrix[k]+vertex.position[1]*matrix[k+4]+vertex.position[2]*matrix[k+8]+matrix[k+12])*w;}
std::copy_n(pos,4,vertex.position);vertex.position[0]-=.5f;reference.push_back(vertex);}
ava2::HardwareBatch cpu{};cpu.indexCount=3;cpu.cull=1;cpu.depth=true;cpu.depthWrite=true;cpu.alphaRef=-1;
SDL_SetRenderDrawColor(renderer,0,0,0,255);SDL_RenderClear(renderer);
assert(resident.Render(renderer,64,64,reference,{0,1,2},{cpu}));
auto* expected=SDL_RenderReadPixels(renderer,nullptr);assert(expected);SDL_RenderPresent(renderer);
assert(expected->format==pixels->format && expected->pitch==pixels->pitch);
size_t different=0;const auto* actual=static_cast<const Uint8*>(pixels->pixels);const auto* wanted=static_cast<const Uint8*>(expected->pixels);
for(int i=0;i<pixels->pitch*pixels->h;++i)if(std::abs(int(actual[i])-int(wanted[i]))>2)++different;
assert(different<16);SDL_DestroySurface(pixels);SDL_DestroySurface(expected);
// Evict only inactive images. Cached batch pointers for the current frame remain valid.
resident.SetTextureBudget(4);
const uint32_t redTexel=0xff0000ff,greenTexel=0xff00ff00;
auto* unused=resident.Texture("budget-old",1,1,&redTexel);assert(unused);
left.texture=resident.Texture("budget-active",1,1,&greenTexel);left.geometry=mesh;left.transform.skin[0]=0;
pixels=frame({left});SDL_DestroySurface(pixels);
pixels=frame({left});SDL_DestroySurface(pixels);
assert(resident.FindTexture("budget-old")==nullptr);
assert(resident.FindTexture("budget-active")==left.texture);
assert(resident.GetTextureBytes()==8); // active texel + protected white working set
const auto uploads=resident.GetTextureUploadCount();
assert(resident.Texture("budget-old",1,1,&redTexel));assert(resident.GetTextureUploadCount()==uploads+1);
left.texture=nullptr;
left.blend=true;right.blend=true;left.transform.skin[0]=0;left.geometry=mesh;
pixels=frame({left,right});SDL_DestroySurface(pixels);assert(resident.GetLastDrawCallCount()==2);
}
SDL_DestroyRenderer(renderer);
renderer=SDL_CreateGPURenderer(device,window);assert(renderer);
UI::DrawText(renderer,"NPC label",12,0,0,0xff00ff00);SDL_RenderPresent(renderer);
SDL_DestroyRenderer(renderer);SDL_DestroyWindow(window);SDL_DestroyGPUDevice(device);SDL_Quit();
float identity[16]={1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1};
float lo[3]={-.1f,-.1f,.1f},hi[3]={.1f,.1f,.9f};
assert(ava2::IsBoundsVisible(lo,hi,identity,identity));
lo[0]=2;hi[0]=3;assert(!ava2::IsBoundsVisible(lo,hi,identity,identity));
lo[0]=-.1f;hi[0]=.1f;lo[2]=-1;hi[2]=.1f;assert(ava2::IsBoundsVisible(lo,hi,identity,identity));
hi[2]=-.1f;assert(!ava2::IsBoundsVisible(lo,hi,identity,identity));
std::puts("DEPTH_ALPHA_PERSPECTIVE_TEXT_AND_FRUSTUM_OK");
}