celisej567/Nuake
1
0
Fork 0
mirror of https://github.com/antopilo/Nuake.git synced 2026-01-03 14:09:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

Mesh cleanup.

Browse Source
This commit is contained in:
a.pilote
2022-06-27 20:12:56 -04:00
parent a8abef1ab2
commit 6b827e9db7
22 changed files with 220 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Editor/src/Windows/EditorInterface.cpp
View File

@@ -822,6 +822,7 @@ namespace Nuake {
// // Unselect delted entity.
// m_SelectedEntity = scene->GetAllEntities().at(0);
//}
}
ImGui::EndChild();

3
Editor/src/Windows/FileSystemUI.cpp
View File

@@ -255,9 +255,8 @@ namespace Nuake {
ImGui::SameLine();
ImGui::Text("/");
}
ImGui::EndChild();
}
ImGui::EndChild();
avail = ImGui::GetContentRegionAvail();

1
Editor/src/Windows/WelcomeWindow.cpp
View File

@@ -216,6 +216,7 @@ namespace Nuake
}
}
}
ImGui::EndChild();
}

11
Nuake/src/Core/Physics/PhysicsShapes.cpp
View File

@@ -1,5 +1,6 @@
#include "PhysicsShapes.h"
#include "btBulletDynamicsCommon.h"
#include "src/Rendering/Vertex.h"
namespace Nuake
{
@@ -52,11 +53,13 @@ namespace Nuake
m_Mesh = mesh;
btTriangleMesh* trimesh = new btTriangleMesh();
for (unsigned int i = 0; i < mesh->m_Indices.size(); i += 3)
auto& indices = mesh->GetIndices();
auto& vertices = mesh->GetVertices();
for (unsigned int i = 0; i < std::size(indices); i += 3)
{
Vector3 tri1 = mesh->m_Vertices[mesh->m_Indices[i]].position;
Vector3 tri2 = mesh->m_Vertices[mesh->m_Indices[i + 1]].position;
Vector3 tri3 = mesh->m_Vertices[mesh->m_Indices[i + 2]].position;
Vector3 tri1 = vertices[indices[i]].position;
Vector3 tri2 = vertices[indices[i + 1]].position;
Vector3 tri3 = vertices[indices[i + 2]].position;
btVector3 btri1 = btVector3(tri1.x, tri1.y, tri1.z);
btVector3 btri2 = btVector3(tri2.x, tri2.y, tri2.z);

6
Nuake/src/Core/Physics/Rigibody.h
View File

@@ -2,9 +2,9 @@
#include "PhysicsShapes.h"
#include "../Core/Core.h"
#include <glm/ext/vector_float3.hpp>
struct btTransform;
struct btRigidBody;
struct btVector3;
class btTransform;
class btRigidBody;
class btVector3;
namespace Nuake
{

3
Nuake/src/Rendering/AABB.h
View File

@@ -1,9 +1,10 @@
#pragma once
#include "src/Core/Maths.h"
namespace Nuake {
class AABB
{
public:
public:
Vector3 Min;
Vector3 Max;

81
Nuake/src/Rendering/Mesh/Mesh.cpp
View File

@@ -1,19 +1,53 @@
#include "Mesh.h"
#include "src/Rendering/Renderer.h"
#include "src/Core/Maths.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Textures/MaterialManager.h"
#include "src/Rendering/Renderer.h"
#include "src/Rendering/Shaders/Shader.h"
#include "src/Rendering/Vertex.h"
#include "src/Rendering/Buffers/VertexBuffer.h"
#include "src/Rendering/Buffers/VertexArray.h"
#include "src/Rendering/Buffers/VertexBufferLayout.h"
namespace Nuake
{
Mesh::Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, Ref<Material> material)
Mesh::Mesh() {}
Mesh::~Mesh() {}
void Mesh::AddSurface(std::vector<Vertex> vertices, std::vector<uint32_t> indices)
{
this->m_Vertices = vertices;
this->m_Indices = indices;
this->m_Material = material;
MaterialManager::Get()->RegisterMaterial(material);
SetupMesh();
CalculateAABB();
if (m_Material == nullptr)
{
m_Material = MaterialManager::Get()->GetMaterial("default");
}
}
std::vector<Vertex>& Mesh::GetVertices()
{
return m_Vertices;
}
std::vector<uint32_t>& Mesh::GetIndices()
{
return m_Indices;
}
Ref<Material> Mesh::GetMaterial() inline const
{
return m_Material;
}
void Mesh::SetMaterial(Ref<Material> material)
{
m_Material = material;
MaterialManager::Get()->RegisterMaterial(material);
}
void Mesh::CalculateAABB()
@@ -24,7 +58,8 @@ namespace Nuake
float maxX = 0.0f;
float maxY = 0.0f;
float maxZ = 0.0f;
for (Vertex& v : m_Vertices)
for (const Vertex& v : m_Vertices)
{
minX = v.position.x < minX ? v.position.x : minX;
minY = v.position.y < minY ? v.position.y : minY;
@@ -33,15 +68,16 @@ namespace Nuake
maxY = v.position.y > maxY ? v.position.y : maxY;
maxZ = v.position.z > maxZ ? v.position.z : maxZ;
}
this->m_AABB = { Vector3(minX, minY, minZ), Vector3(maxX, maxY, maxZ) };
}
void Mesh::SetupMesh()
{
m_VertexArray = new VertexArray();
m_VertexArray = CreateScope<VertexArray>();
m_VertexArray->Bind();
m_VertexBuffer = new VertexBuffer(m_Vertices.data(), m_Vertices.size() * sizeof(Vertex));
m_ElementBuffer = new VertexBuffer(m_Indices.data(), m_Indices.size() * sizeof(unsigned int), RendererEnum::ELEMENT_ARRAY_BUFFER);
m_VertexBuffer = CreateScope<VertexBuffer>(m_Vertices.data(), m_Vertices.size() * sizeof(Vertex));
m_ElementBuffer = CreateScope<VertexBuffer>(m_Indices.data(), m_Indices.size() * sizeof(unsigned int), RendererEnum::ELEMENT_ARRAY_BUFFER);
VertexBufferLayout bufferLayout = VertexBufferLayout();
bufferLayout.Push<float>(3); // Position
@@ -72,4 +108,31 @@ namespace Nuake
m_VertexArray->Bind();
RenderCommand::DrawElements(RendererEnum::TRIANGLES, m_Indices.size(), RendererEnum::UINT, 0);
}
json Mesh::Serialize()
{
BEGIN_SERIALIZE();
j["Material"] = m_Material->Serialize();
j["Indices"] = m_Indices;
for (unsigned int i = 0; i < m_Vertices.size(); i++)
{
j["Vertices"][i]["Position"] = SERIALIZE_VEC3(m_Vertices[i].position);
j["Vertices"][i]["Normal"] = SERIALIZE_VEC3(m_Vertices[i].normal);
j["Vertices"][i]["UV"] = SERIALIZE_VEC2(m_Vertices[i].uv);
j["Vertices"][i]["Tangent"] = SERIALIZE_VEC3(m_Vertices[i].tangent);
j["Vertices"][i]["Bitangent"] = SERIALIZE_VEC3(m_Vertices[i].bitangent);
}
END_SERIALIZE();
}
bool Mesh::Deserialize(const std::string& str)
{
BEGIN_DESERIALIZE();
return true;
}
}

71
Nuake/src/Rendering/Mesh/Mesh.h
View File

@@ -1,68 +1,49 @@
#pragma once
#include "src/Core/Core.h"
#include "src/Core/Maths.h"
#include "src/Rendering/Shaders/Shader.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Vertex.h"
#include "src/Rendering/Buffers/VertexBuffer.h"
#include "src/Rendering/Buffers/VertexArray.h"
#include "src/Rendering/Buffers/VertexBufferLayout.h"
#include "src/Rendering/AABB.h"
#include "src/Resource/Resource.h"
#include <src/Resource/Serializable.h>
namespace Nuake
{
class Mesh
class VertexBuffer;
class VertexArray;
class Material;
class Vertex;
class Shader;
class Mesh : ISerializable, Resource
{
public:
std::vector<unsigned int> m_Indices;
std::vector<Vertex> m_Vertices;
Ref<Material> m_Material;
Mesh();
~Mesh();
void AddSurface(std::vector<Vertex> vertices, std::vector<uint32_t> indices);
std::vector<Vertex>& GetVertices();
std::vector<uint32_t>& GetIndices();
Mesh(std::vector<Vertex> vertices, std::vector<unsigned int> indices, Ref<Material> material);
Ref<Material> GetMaterial() inline const;
void SetMaterial(Ref<Material> material);
void Draw(Shader* shader, bool bindMaterial = true);
void DebugDraw();
inline AABB GetAABB() const { return m_AABB; }
json Serialize()
{
BEGIN_SERIALIZE();
j["Material"] = m_Material->Serialize();
j["Indices"] = m_Indices;
for (unsigned int i = 0; i < m_Vertices.size(); i++)
{
j["Vertices"][i]["Position"] = SERIALIZE_VEC3(m_Vertices[i].position);
j["Vertices"][i]["Normal"] = SERIALIZE_VEC3(m_Vertices[i].normal);
j["Vertices"][i]["UV"] = SERIALIZE_VEC2(m_Vertices[i].uv);
j["Vertices"][i]["Tangent"] = SERIALIZE_VEC3(m_Vertices[i].tangent);
j["Vertices"][i]["Bitangent"] = SERIALIZE_VEC3(m_Vertices[i].bitangent);
}
END_SERIALIZE();
}
bool Deserialize(std::string str)
{
BEGIN_DESERIALIZE();
return true;
}
json Serialize() override;
bool Deserialize(const std::string& str) override;
private:
VertexBuffer* m_VertexBuffer;
VertexArray* m_VertexArray;
VertexBuffer* m_ElementBuffer;
Ref<Material> m_Material = nullptr;
std::vector<uint32_t> m_Indices;
std::vector<Vertex> m_Vertices;
Scope<VertexBuffer> m_VertexBuffer;
Scope<VertexArray> m_VertexArray;
Scope<VertexBuffer> m_ElementBuffer;
unsigned int VAO, VBO, EBO;
void SetupMesh();
AABB m_AABB;
void CalculateAABB();
};
}
}

4
Nuake/src/Rendering/PostFX/Bloom.h
View File

@@ -20,8 +20,8 @@ namespace Nuake {
private:
float m_Threshold = 2.3f;
float m_BlurAmount = 12.0f;
unsigned int m_Iteration;
Vector2 m_Size;
uint32_t m_Iteration = 4;
Vector2 m_Size = Vector2();
Ref<Texture> m_Source;
Ref<FrameBuffer> m_FinalFB;

4
Nuake/src/Rendering/PostFX/Volumetric.cpp
View File

@@ -28,7 +28,7 @@ namespace Nuake {
return;
mSize = size * mRenderRatio;
Init();
mFinalFramebuffer->QueueResize(mSize);
}
void Volumetric::Draw(Matrix4 projection, Matrix4 view, std::vector<LightComponent>& lights)
@@ -37,7 +37,6 @@ namespace Nuake {
mFinalFramebuffer->Clear();
RenderCommand::Disable(RendererEnum::FACE_CULL);
Vector3 cameraPosition = view[3];
Shader* volumetricShader = ShaderManager::GetShader("resources/Shaders/volumetric.shader");
volumetricShader->Bind();
@@ -62,7 +61,6 @@ namespace Nuake {
}
Renderer::DrawQuad();
mFinalFramebuffer->Unbind();

8
Nuake/src/Rendering/RenderList.h
View File

@@ -24,10 +24,12 @@ namespace Nuake
void AddToRenderList(Ref<Mesh> mesh, Matrix4 transform)
{
if (m_RenderList.find(mesh->m_Material) == m_RenderList.end())
m_RenderList[mesh->m_Material] = std::vector<RenderMesh>();
Ref<Material> material = mesh->GetMaterial();
m_RenderList[mesh->m_Material].push_back({mesh, transform});
if (m_RenderList.find(material) == m_RenderList.end())
m_RenderList[material] = std::vector<RenderMesh>();
m_RenderList[material].push_back({mesh, transform});
}
void Flush(Shader* shader, bool depthOnly = false)

6
Nuake/src/Rendering/Renderer.cpp
View File

@@ -81,9 +81,9 @@ namespace Nuake
m_LightsUniformBuffer = CreateRef<UniformBuffer>(128);
Ref<Material> material = MaterialManager::Get()->GetMaterial("default");
CubeMesh = CreateRef<Mesh>(CubeVertices, CubeIndices, material);
CubeMesh = CreateRef<Mesh>();
CubeMesh->AddSurface(CubeVertices, CubeIndices);
CubeMesh->SetMaterial(material);
// Cube buffer
//CubeVertexArray = new VertexArray();
//CubeVertexArray->Bind();

7
Nuake/src/Rendering/SceneRenderer.cpp
View File

@@ -76,7 +76,6 @@ namespace Nuake {
mVolumetric->SetDepth(mGBuffer->GetTexture(GL_DEPTH_ATTACHMENT).get());
mVolumetric->Draw(mProjection , mView, lightList);
finalOutput = mVolumetric->GetFinalOutput();
}
@@ -95,8 +94,8 @@ namespace Nuake {
}
mToneMapBuffer->Unbind();
mSSR->Resize(framebuffer.GetSize());
mSSR->Draw(mGBuffer.get(), framebuffer.GetTexture(), mView, mProjection, scene.GetCurrentCamera());
//mSSR->Resize(framebuffer.GetSize());
//mSSR->Draw(mGBuffer.get(), framebuffer.GetTexture(), mView, mProjection, scene.GetCurrentCamera());
framebuffer.Bind();
{
@@ -105,7 +104,7 @@ namespace Nuake {
shader->Bind();
shader->SetUniformTex("u_Source", mToneMapBuffer->GetTexture().get(), 0);
shader->SetUniformTex("u_Source2", mSSR->OutputFramebuffer->GetTexture().get(), 1);
shader->SetUniformTex("u_Source2", mToneMapBuffer->GetTexture().get(), 1);
Renderer::DrawQuad();
}
framebuffer.Unbind();

40
Nuake/src/Resource/Resource.h
View File

@@ -1,48 +1,20 @@
#pragma once
#include "src/Resource/UUID.h"
#include <string>
#include <vector>
#include "src/Rendering/Mesh/Mesh.h"
namespace Nuake {
enum class ResourceType
{
Texture,
Prefab,
Map,
Mesh,
Shader,
};
namespace Nuake
{
class Resource
{
public:
unsigned int Id;
ResourceType Type;
UUID Id;
bool IsEmbedded;
bool IsEmbedded = false;
std::string Path; // Only if embedded
void MakeExternal();
void Duplicate();
void MakeEmbedded();
};
class TextureResource : Resource
{
public:
std::string TexturePath;
// texture flags
};
class ModelResource : Resource
{
public:
std::vector<Ref<Mesh>> SubMeshes;
ModelResource();
bool Load(const std::string& path);
};
}

5
Nuake/src/Resource/ResourceManager.h
View File

@@ -8,9 +8,12 @@
namespace Nuake {
class ResourceManager {
private:
static std::unordered_map<UUID, Ref<Resource>> m_Resources;
static std::map<UUID, Ref<Resource>> m_Resources;
public:
static Ref<Resource> GetResource(const UUID& uuid);
template<typename R>
static Ref<R> LoadResource(const std::string& path);
};
}

6
Nuake/src/Scene/Components/MeshComponent.cpp
View File

@@ -206,7 +206,11 @@ namespace Nuake {
}
//newMaterial->SetAO(TextureManager::Get()->GetTexture(directory + str.C_Str()));
return CreateRef<Mesh>(vertices, indices, newMaterial);
Ref<Mesh> nuakeMesh = CreateRef<Mesh>();
nuakeMesh->AddSurface(vertices, indices);
nuakeMesh->SetMaterial(newMaterial);
return nuakeMesh;
}
std::vector<Texture*> MeshComponent::LoadMaterialTextures(aiMaterial* mat, aiTextureType type)

3
Nuake/src/Scene/Components/MeshComponent.h
View File

@@ -1,7 +1,10 @@
#pragma once
#include <glm/ext/matrix_float4x4.hpp>
#include <vector>
#include "src/Rendering/Mesh/Mesh.h"
#include "src/Rendering/Textures/Texture.h"
#include "src/Resource/Serializable.h"
#include "assimp/Importer.hpp"
#include <assimp/scene.h>

11
Nuake/src/Scene/Scene.h
View File

@@ -14,6 +14,9 @@
#include "src/Scene/Systems/System.h"
#include "src/Resource/UUID.h"
#include "src/Resource/Resource.h"
namespace Nuake {
class Entity;
class SceneRenderer;
@@ -29,6 +32,8 @@ namespace Nuake {
// In the scene constructor.
std::vector<Ref<System>> m_Systems;
Ref<Environment> m_Environement;
std::map<UUID, Ref<Resource>> m_Resources;
public:
Ref<EditorCamera> m_EditorCamera;
entt::registry m_Registry;
@@ -68,6 +73,12 @@ namespace Nuake {
Ref<Environment> GetEnvironment() const;
void SetEnvironment(Ref<Environment> env);
template<class T>
Ref<T> GetResource(const UUID& uuid)
{
return m_Resources[uuid];
}
bool Save();
bool SaveAs(const std::string& path);
Ref<Scene> Copy();

82
Nuake/src/Scene/Systems/QuakeMapBuilder.cpp
View File

@@ -1,12 +1,12 @@
#include "QuakeMapBuilder.h"
#include "src/Rendering/Mesh/Mesh.h"
#include "src/Core/FileSystem.h"
#include "src/Core/String.h"
#include "src/Scene/Scene.h"
#include "src/Scene/Entities/Entity.h"
#include "src/Scene/Components/QuakeMap.h"
#include "src/Scene/Components/ParentComponent.h"
#include <vector>
#include <map>
extern "C" {
#include <libmap/h/map_parser.h>
@@ -24,14 +24,16 @@ extern "C" {
#include "src/Scene/Components/WrenScriptComponent.h"
#include "src/Scene/Components/PrefabComponent.h"
#include <vector>
#include <map>
namespace Nuake {
struct ProcessedMesh
{
std::vector<Vertex> Vertices;
std::vector<unsigned int> Indices;
std::vector<uint32_t> Indices;
};
Ref<Material> DefaultMaterial;
void QuakeMapBuilder::CreateTrigger(brush* brush, brush_geometry* brush_inst,
@@ -92,7 +94,10 @@ namespace Nuake {
indexOffset += face_geo_inst->vertex_count;
}
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
bsp.Meshes.push_back(mesh);
}
void QuakeMapBuilder::CreateBrush(brush* brush, brush_geometry* brush_inst,
@@ -170,10 +175,16 @@ namespace Nuake {
{
lastTexturePath = FileSystem::Root + "textures/" + std::string(texture->name) + ".png";
if (std::string(texture->name) == "__TB_empty")
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
else
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
if (std::string(texture->name) != "__TB_empty")
{
Ref<Material> material = MaterialManager::Get()->GetMaterial(lastTexturePath);
mesh->SetMaterial(material);
}
bsp.Meshes.push_back(mesh);
index_offset = 0;
vertices.clear();
@@ -187,7 +198,15 @@ namespace Nuake {
}
if (vertices.size() > 0)
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
{
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
Ref<Material> material = MaterialManager::Get()->GetMaterial(lastTexturePath);
mesh->SetMaterial(material);
bsp.Meshes.push_back(mesh);
}
}
void QuakeMapBuilder::CreateFuncBrush(brush* brush, brush_geometry* brush_inst,
@@ -293,10 +312,16 @@ namespace Nuake {
if (lastTextureID != face->texture_idx)
{
lastTexturePath = FileSystem::Root + "textures/" + std::string(texture->name) + ".png";
if (std::string(texture->name) == "__TB_empty")
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
else
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
if (std::string(texture->name) != "__TB_empty")
{
Ref<Material> material = MaterialManager::Get()->GetMaterial(lastTexturePath);
mesh->SetMaterial(material);
}
bsp.Meshes.push_back(mesh);
index_offset = 0;
vertices.clear();
@@ -316,12 +341,23 @@ namespace Nuake {
if (bsp.IsTrigger)
{
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, DefaultMaterial));
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
bsp.Meshes.push_back(mesh);
vertices.clear();
}
if (vertices.size() > 0)
bsp.Meshes.push_back(CreateRef<Mesh>(vertices, indices, MaterialManager::Get()->GetMaterial(lastTexturePath)));
{
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(vertices, indices);
Ref<Material> material = MaterialManager::Get()->GetMaterial(lastTexturePath);
mesh->SetMaterial(material);
bsp.Meshes.push_back(mesh);
}
}
void QuakeMapBuilder::BuildQuakeMap(Entity& ent, bool Collisions)
@@ -499,7 +535,7 @@ namespace Nuake {
face_geometry* face_geo_inst = &brush_geo_inst->faces[f];
std::vector<Vertex> vertices;
std::vector<unsigned int> indices;
std::vector<uint32_t> indices;
for (int i = 0; i < face_geo_inst->vertex_count; ++i)
{
face_vertex vertex = face_geo_inst->vertices[i];
@@ -533,7 +569,7 @@ namespace Nuake {
for (int i = 0; i < (face_geo_inst->vertex_count - 2) * 3; ++i)
{
unsigned int index = face_geo_inst->indices[i];
uint32_t index = face_geo_inst->indices[i];
indices.push_back((unsigned int)index);
}
@@ -548,8 +584,8 @@ namespace Nuake {
for (auto& mat : m_StaticWorld)
{
std::vector<Vertex> batchedVertices;
std::vector<unsigned int> batchedIndices;
int indexOffset = 0;
std::vector<uint32_t> batchedIndices;
uint32_t indexOffset = 0;
for (auto& pm : mat.second)
{
for(auto& vert : pm.Vertices)
@@ -561,7 +597,11 @@ namespace Nuake {
indexOffset += pm.Vertices.size();
}
bsp.Meshes.push_back(CreateRef<Mesh>(batchedVertices, batchedIndices, mat.first));
Ref<Mesh> mesh = CreateRef<Mesh>();
mesh->AddSurface(batchedVertices, batchedIndices);
mesh->SetMaterial(mat.first);
bsp.Meshes.push_back(mesh);
}
}

10
Nuake/src/UI/Font/Font.h
View File

@@ -23,15 +23,11 @@ namespace Nuake
class Char
{
private:
unsigned int m_VBO;
unsigned int m_VAO;
public:
unsigned int Unicode;
float Advance;
uint32_t Unicode;
float Advance = 0.f;
CharPos PlaneBounds;
CharUV AtlasBounds;
CharUV AtlasBounds = {};
Char() {};
Char(const unsigned int unicode, float advance, CharPos plane, CharUV atlas)

15
Nuake/src/Window.cpp
View File

@@ -19,23 +19,8 @@
#include "Resource/FontAwesome5.h"
#include "Engine.h"
#include <src/Scene/Components/InterfaceComponent.h>
#include "src/Rendering/PostFX/Bloom.h"
namespace Nuake {
// TODO: Use abstraction for vertex buffers
unsigned int vbo;
unsigned int vao;
// TODO: Move to primitive storage.
float vertices[] = {
1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
-1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
};
Ref<Window> Window::s_Instance;
Window::Window()

BIN
premake5.exe
View File

Binary file not shown.