Files
AVA2/tests/hardware_scene_test.cpp
T
shenandshen 281418f351 Fix cross-platform rendering and optimize frame performance
Correct selection orientation, game-entry lifecycle, mounted NPCs, labels and skill panels. Add the native GPU scene path, resident geometry, bounded texture and Python caches, and collision broad phase.

Pin the independently maintained Metin2 SDK through a submodule and document reproducible setup. Include rendering regressions and macOS packaging improvements.

Validation: client Debug build and 12 targeted client tests passed; SDK build and all 14 SDK tests passed.
2026-10-11 17:55:53 -07:00

194 lines
13 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() {
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},{r,g,b,alpha},{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]=1;
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));
}
{
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);
}
{
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);
// Bone translation moves the raw triangle to the center; no CPU-deformed stream is uploaded.
left.transform.skin[0]=1;left.palette={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={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];
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");
}