Files
AVA2/tests/hardware_scene_test.cpp

271 lines
20 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);
// Original FlyTrace uses LESS, additive blending and inherited depth write.
auto equal=near;equal.cull=1;equal.firstIndex=3;equal.blend=equal.additive=true;equal.depthLess=true;
for(int i=3;i<6;++i)vertices[i].position[2]=.2f;
near.cull=1;color=center({near,equal});assert(color[0]>245 && color[1]<5);
equal.depthLess=false;color=center({near,equal});assert(color[0]>245 && color[1]>245);
equal.depthLess=true;equal.depthWrite=true;color=center({equal,near});assert(color[0]>245 && color[1]<5); // near defaults LESSEQUAL
auto behind=near;behind.firstIndex=6;behind.depthLess=true;
for(int i=6;i<9;++i){vertices[i].position[2]=.4f;vertices[i].color[3]=255;}
color=center({equal,behind});assert(color[1]>245 && color[2]<5);
equal.depthWrite=false;color=center({equal,behind});assert(color[2]>245 && color[1]<5);
equal.depth=false;color=center({near,equal});assert(color[0]>245 && color[1]>245);
for(int i=3;i<6;++i)vertices[i].position[2]=.8f;
for(int i=6;i<9;++i){vertices[i].position[2]=.1f;vertices[i].color[3]=51;}
// Tree bark/canopy use the same strict alpha=84 mask. Equal must not write depth.
auto maskedTree=near;maskedTree.cull=1;maskedTree.alphaRef=84.f/255;
const Uint8 alpha84[4]={255,0,0,84},alpha85[4]={255,0,0,85},alpha0[4]={255,0,0,0},alpha1[4]={255,0,0,1};
maskedTree.texture=scene.Texture("tree-alpha84",1,1,alpha84);color=center({maskedTree,far});assert(color[1]>245&&color[0]<5);
maskedTree.texture=scene.Texture("tree-alpha85",1,1,alpha85);color=center({maskedTree,far});assert(color[0]>245&&color[1]<5);
maskedTree.alphaRef=0;maskedTree.texture=scene.Texture("tree-alpha0",1,1,alpha0);color=center({maskedTree,far});assert(color[1]>245&&color[0]<5);
maskedTree.texture=scene.Texture("tree-alpha1",1,1,alpha1);color=center({maskedTree,far});assert(color[0]>245&&color[1]<5);
// 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");
}