271 lines
20 KiB
C++
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");
|
|
}
|