#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 #include #include #include #include #include #include #include #include #include int main() { { // Referenced (cached) commands splice in before owned[before], in submission order. std::vector owned(3);ava2::Render3DDraw cachedA,cachedB,cachedC; std::vector refs{{1,&cachedA},{1,&cachedB},{3,&cachedC}}; std::vector list;ava2::FlattenDraws(owned,refs,list); const std::vector 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 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 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 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(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{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 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(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(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{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(header),sizeof(header));uint32_t red[4]={0xff0000ff,0xff0000ff,0xff0000ff,0xff0000ff};file.write(reinterpret_cast(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(4,0xff0000ff); auto readOrder=[&](const std::vector& 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(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{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(); 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 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(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(*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(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{1,0,0,0,0,1,0,0,0,0,1,0,.5f,0,0,1}); auto skinned=std::make_shared(*mesh);skinned->bone_indices=std::vector(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{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(*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 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(pixels->pixels);const auto* wanted=static_cast(expected->pixels); for(int i=0;ipitch*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"); }