GPU SDL3 отображает только первый нарисованный объект ⇐ C++

[Anonymous]

Всякий раз, когда я называю DrawTexture , это только то, что визуализируется первым нарисованным объектом, и я не знаю, как другие нарисованные объекты получают запутываемые/игнорируемые.#include
#include
#include
#include
#include
#include
#include
#include
namespace rbur {
Vertex quad[4]{
{{-.5, -.5}, {0, 1.f}, {1, 1, 1, 1}},
{{.5f, -.5}, {1, 1.f}, {1, 1, 1, 1}},
{{-.5, .5f}, {0.f, 0.f}, {1, 1, 1, 1}},
{{.5f, .5f}, {1.f, 0.f}, {1, 1, 1, 1}},
};
SDL_GPUBuffer* quadBuffer = NULL;

SDL_GPUCommandBuffer* drawCmdBuf = NULL; // Used for all of a frames draw calls
SDL_GPURenderPass* pass = NULL;
SDL_GPUTexture* swapchainTex = NULL;
SDL_GPUSampler* nearestSampler = NULL;

SDL_GPUBuffer* makeGPUVertexBuffer(const std::span& vertices) {
SDL_GPUBufferCreateInfo bufInfo = {};
bufInfo.usage = SDL_GPU_BUFFERUSAGE_VERTEX;
bufInfo.size = vertices.size_bytes();
bufInfo.props = 0;
SDL_GPUBuffer* buf = SDL_CreateGPUBuffer(rbur::device, &bufInfo);

SDL_GPUTransferBufferCreateInfo transferInfo = {};
transferInfo.size = vertices.size_bytes();
transferInfo.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
transferInfo.props = 0;
SDL_GPUTransferBuffer* transferBuf = SDL_CreateGPUTransferBuffer(rbur::device, &transferInfo);

rbur::Vertex* data = (rbur::Vertex*)SDL_MapGPUTransferBuffer(rbur::device, transferBuf, false);
for (size_t i = 0; i < vertices.size(); i++) {
data = vertices;
}
SDL_UnmapGPUTransferBuffer(rbur::device, transferBuf);

SDL_GPUCommandBuffer* commandBuf = SDL_AcquireGPUCommandBuffer(device);
SDL_GPUCopyPass* copyPass = SDL_BeginGPUCopyPass(commandBuf);
SDL_GPUTransferBufferLocation location = {};
location.offset = 0;
location.transfer_buffer = transferBuf;
SDL_GPUBufferRegion region = {};
region.offset = 0;
region.buffer = buf;
region.size = vertices.size_bytes();
SDL_UploadToGPUBuffer(copyPass, &location, &region, false);
SDL_EndGPUCopyPass(copyPass);
SDL_ReleaseGPUTransferBuffer(device, transferBuf);
SDL_SubmitGPUCommandBuffer(commandBuf);

return buf;
}

void initRenderLib() {
quadBuffer = makeGPUVertexBuffer(std::span(quad, std::size(quad)));
drawCmdBuf = SDL_AcquireGPUCommandBuffer(device);

SDL_GPUSamplerCreateInfo samplerCreateInfo;
samplerCreateInfo.min_filter = SDL_GPU_FILTER_NEAREST;
samplerCreateInfo.mag_filter = SDL_GPU_FILTER_NEAREST;
samplerCreateInfo.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_REPEAT;
samplerCreateInfo.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_REPEAT;
samplerCreateInfo.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_REPEAT;
samplerCreateInfo.compare_op = SDL_GPU_COMPAREOP_NEVER;
samplerCreateInfo.enable_compare = false;
samplerCreateInfo.enable_anisotropy = false;
samplerCreateInfo.min_lod = 0.0;
samplerCreateInfo.max_lod = 0.0;
samplerCreateInfo.mip_lod_bias = 0.0;
samplerCreateInfo.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST;
samplerCreateInfo.props = 0;
nearestSampler = SDL_CreateGPUSampler(device, &samplerCreateInfo);
}
void cleanupRenderLib() {
SDL_EndGPURenderPass(pass);
SDL_SubmitGPUCommandBuffer(drawCmdBuf);
SDL_ReleaseGPUSampler(device, nearestSampler);
SDL_ReleaseGPUBuffer(device, quadBuffer);

drawCmdBuf = nullptr;
quadBuffer = nullptr;
nearestSampler = nullptr;
}

void flipScreen(const glm::vec4& clearColor) {
if (pass) {
SDL_EndGPURenderPass(pass);
pass = NULL;
}

SDL_SubmitGPUCommandBuffer(drawCmdBuf);
drawCmdBuf = SDL_AcquireGPUCommandBuffer(device);
if (SDL_WaitAndAcquireGPUSwapchainTexture(drawCmdBuf, window, &swapchainTex, NULL, NULL)) {
SDL_GPUColorTargetInfo targetInfo[2];
for (size_t i = 0; i < std::size(targetInfo); i++) {
targetInfo.texture = swapchainTex;
targetInfo.load_op = SDL_GPU_LOADOP_CLEAR;
targetInfo.store_op = SDL_GPU_STOREOP_STORE;
targetInfo.clear_color = SDL_FColor{ clearColor.r, clearColor.g, clearColor.b, clearColor.a };
targetInfo.cycle = false;
targetInfo.mip_level = 0;
targetInfo.resolve_texture = NULL;
targetInfo.layer_or_depth_plane = 0;
}

pass = SDL_BeginGPURenderPass(drawCmdBuf, targetInfo, 1, NULL);
SDL_EndGPURenderPass(pass);
for (size_t i = 0; i < std::size(targetInfo); i++) {
targetInfo[i].load_op = SDL_GPU_LOADOP_LOAD;
targetInfo[i].store_op = SDL_GPU_STOREOP_STORE;
}

pass = SDL_BeginGPURenderPass(drawCmdBuf, targetInfo, 1, NULL);

}
}
void drawTexture(const Texture* tex, const glm::vec2& pos, Shader* shader) {
if (!swapchainTex)
return;
if (!shader)
return;
if (shader->fragmentShader() == nullptr || shader->vertexShader() == nullptr)
return;
if (!tex || !tex->getInternalTexture())
return;

glm::mat4 model = glm::identity();
model = glm::translate(model, glm::vec3(pos, 0.f));
model = glm::scale(model, glm::vec3(tex->getWidth(), tex->getHeight(), 1.f));

glm::mat4 view = glm::identity();
// Cameras transform goes here
view = glm::inverse(view);

int winW, winH;
SDL_GetWindowSize(window, &winW, &winH);
glm::mat4 projection = glm::ortho(-winW / 2.f, winW / 2.f, winH / 2.f, -winH / 2.f);

glm::mat4 MVP = projection * view * model;
shader->setUniform("TRANSFORM", MVP);

static constexpr auto asAddress = [](const auto& val)->auto {
return &val;
};

SDL_BindGPUGraphicsPipeline(pass, shader->getRenderPipeline());
SDL_BindGPUVertexBuffers(pass, 0, asAddress((SDL_GPUBufferBinding) { .buffer = quadBuffer, .offset = 0 }), 1);
SDL_BindGPUVertexSamplers(pass, 0, asAddress((SDL_GPUTextureSamplerBinding) { .texture = tex->getInternalTexture(), .sampler = nearestSampler }), 1);

shader->updateUniforms(drawCmdBuf);
SDL_DrawGPUPrimitives(pass, 4, 1, 0, 0);
}

bool registerRenderLib(asIScriptEngine* engine) {
if (!engine)
return false;

engine->SetDefaultNamespace("");
engine->RegisterObjectType("Color", sizeof(glm::vec4), asOBJ_VALUE | asOBJ_POD);
engine->RegisterObjectProperty("Color", "float r", offsetof(glm::vec4, r));
engine->RegisterObjectProperty("Color", "float g", offsetof(glm::vec4, g));
engine->RegisterObjectProperty("Color", "float b", offsetof(glm::vec4, b));
engine->RegisterObjectProperty("Color", "float a", offsetof(glm::vec4, a));
engine->RegisterObjectBehaviour("Color", asBEHAVE_CONSTRUCT, "void ctor(float r = 0, float g = 0, float b = 0, float a = 1)", asFUNCTIONPR([](glm::vec4* obj, float r, float g, float b, float a) {
new (obj) glm::vec4(r, g, b, a);
}, (glm::vec4*, float r, float g, float b, float a), void), asCALL_CDECL_OBJFIRST);

engine->RegisterObjectType("Texture", 0, asOBJ_REF);
engine->RegisterObjectBehaviour("Texture", asBEHAVE_FACTORY, "Texture@ factory()", asFUNCTIONPR([]() {
return Texture::createTexture();
}, (), Texture*), asCALL_CDECL);
engine->RegisterObjectBehaviour("Texture", asBEHAVE_FACTORY, "Texture@ factory(const string&in)", asFUNCTIONPR([](const std::string& file) {
return Texture::createTexture(file);
}, (const std::string&), Texture*), asCALL_CDECL);
engine->RegisterObjectBehaviour("Texture", asBEHAVE_ADDREF, "void addRef()", asMETHOD(Texture, addRef), asCALL_THISCALL);
engine->RegisterObjectBehaviour("Texture", asBEHAVE_RELEASE, "void release()", asMETHOD(Texture, removeRef), asCALL_THISCALL);
engine->RegisterObjectMethod("Texture", "int get_width() const property", asMETHOD(Texture, getWidth), asCALL_THISCALL);
engine->RegisterObjectMethod("Texture", "int get_height() const property", asMETHOD(Texture, getHeight), asCALL_THISCALL);
engine->RegisterObjectMethod("Texture", "bool LoadFromFile(const string&in)", asMETHOD(Texture, loadFromFile), asCALL_THISCALL);

engine->RegisterObjectType("Shader", 0, asOBJ_REF);
engine->RegisterObjectBehaviour("Shader", asBEHAVE_FACTORY, "Shader@ factory()", asFUNCTIONPR([]() {
return new Shader();
}, (), Shader*), asCALL_CDECL);
engine->RegisterObjectBehaviour("Shader", asBEHAVE_ADDREF, "void addRef()", asMETHOD(Shader, addRef), asCALL_THISCALL);
engine->RegisterObjectBehaviour("Shader", asBEHAVE_RELEASE, "void release()", asMETHOD(Shader, removeRef), asCALL_THISCALL);
engine->RegisterObjectMethod("Shader", "Result LoadFromFile(const string&in)", asMETHOD(Shader, loadFromFile), asCALL_THISCALL);
engine->RegisterObjectMethod("Shader", "bool SetUniform(const string&in, const Color&in)", asMETHODPR(Shader, setUniform, (const std::string&, const glm::vec4&), bool), asCALL_THISCALL);
engine->RegisterObjectMethod("Shader", "bool SetUniform(const string&in, float)", asMETHODPR(Shader, setUniform, (const std::string&, float), bool), asCALL_THISCALL);
// engine->RegisterObjectMethod("Shader", "bool SetUniform(const string&in, Texture@)", asMETHODPR(Shader, setUniform, (const std::string&, Texture*), bool), asCALL_THISCALL);

engine->RegisterGlobalFunction("void FlipScreen(const Color&in clearColor)", asFUNCTIONPR(flipScreen, (const glm::vec4&), void), asCALL_CDECL);
engine->RegisterGlobalFunction("void DrawTexture(const Texture@ tex, const Vector2f&in rect, Shader@ shader)", asFUNCTIONPR(drawTexture, (const Texture*, const glm::vec2&, Shader*), void), asCALL_CDECL);
return true;
}
}
< /code>
Я ожидаю увидеть несколько объектов на экране при рисовании более 1 объекта.initRenderLib вызывается на OpenWindow , а Cleanuprenderlib вызывает на BloseWindow
int main(string[] args){
OpenWindow("Game", Vector2i(800, 600), WindowFlags::Resizable );
Println("Resizable: %", WindowFlags::Resizable);

Texture@ tex = Texture("res/Jimmy.png");
Println("Loaded texture: %", @tex != null);
Shader@ shader = Shader();
Result res = shader.LoadFromFile("res/Default.hlsl");
Println("Loaded shader: %", res.success);
if (!res)
Println("Error: %", res.message);

bool open = true;
while (open){
Event ev;
while (PollEvent(ev)){
if (ev.type == EventType::Closed){
open = false;
}
if (ev.type == EventType::MouseUp){
if (ev.button == MouseButton::Left){
Println("Clicked");
}
}
if (ev.type == EventType::KeyDown){
if (ev.key == Key::Escape){
open = false;
}
else if (ev.key == Key::Num0){
Println("Pressed !");
}
}
}
FlipScreen(Color(.8, .5, .2, 1));

DrawTexture(tex, Vector2f(-128, -128), shader); // Only draw object that is visible
DrawTexture(tex, Vector2f(0, 0), shader);
DrawTexture(tex, Vector2f(128, 128), shader);
}

CloseWindow();

return 0;
}


Подробнее здесь: https://stackoverflow.com/questions/797 ... ject-drawn