TheZone/ScuffedMinecraft
1
0
Fork 0
Code Issues 7 Pull Requests 4 Actions Packages Projects Releases 5 Wiki Activity

Episode 2

Browse Source
This commit is contained in:
WSAL Evan 2024-09-20 07:41:34 -04:00
parent 2b5b5dcb94
commit ad910a47f1
13 changed files with 234 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
ScuffedMinecraft/ScuffedMinecraft.vcxproj
View File

@ -71,20 +71,20 @@
</ImportGroup> </ImportGroup>
<PropertyGroup Label="UserMacros" /> <PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<IncludePath>C:\dev\C++\ScuffedMinecraft\Dependencies\include;$(IncludePath)</IncludePath> <IncludePath>$(SolutionDir)Dependencies\include;$(IncludePath)</IncludePath>
<LibraryPath>C:\dev\C++\ScuffedMinecraft\Dependencies\lib;$(LibraryPath)</LibraryPath> <LibraryPath>$(SolutionDir)Dependencies\lib;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<IncludePath>C:\dev\C++\ScuffedMinecraft\Dependencies\include;$(IncludePath)</IncludePath> <IncludePath>$(SolutionDir)Dependencies\include;$(IncludePath)</IncludePath>
<LibraryPath>C:\dev\C++\ScuffedMinecraft\Dependencies\lib;$(LibraryPath)</LibraryPath> <LibraryPath>$(SolutionDir)Dependencies\lib;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<IncludePath>C:\dev\C++\ScuffedMinecraft\Dependencies\include;$(IncludePath)</IncludePath> <IncludePath>$(SolutionDir)Dependencies\include;$(IncludePath)</IncludePath>
<LibraryPath>C:\dev\C++\ScuffedMinecraft\Dependencies\lib;$(LibraryPath)</LibraryPath> <LibraryPath>$(SolutionDir)Dependencies\lib;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<IncludePath>C:\dev\C++\ScuffedMinecraft\Dependencies\include;$(IncludePath)</IncludePath> <IncludePath>$(SolutionDir)Dependencies\include;$(IncludePath)</IncludePath>
<LibraryPath>C:\dev\C++\ScuffedMinecraft\Dependencies\lib;$(LibraryPath)</LibraryPath> <LibraryPath>$(SolutionDir)Dependencies\lib;$(LibraryPath)</LibraryPath>
</PropertyGroup> </PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile> <ClCompile>
@ -155,6 +155,7 @@
<ClCompile Include="src\Block.cpp" /> <ClCompile Include="src\Block.cpp" />
<ClCompile Include="src\Camera.cpp" /> <ClCompile Include="src\Camera.cpp" />
<ClCompile Include="src\Chunk.cpp" /> <ClCompile Include="src\Chunk.cpp" />
<ClCompile Include="src\NoiseSettings.cpp" />
<ClCompile Include="src\Planet.cpp" /> <ClCompile Include="src\Planet.cpp" />
<ClCompile Include="src\Shader.cpp" /> <ClCompile Include="src\Shader.cpp" />
<ClCompile Include="src\TupleHash.h" /> <ClCompile Include="src\TupleHash.h" />
@ -174,6 +175,7 @@
<ClInclude Include="src\Blocks.h" /> <ClInclude Include="src\Blocks.h" />
<ClInclude Include="src\Camera.h" /> <ClInclude Include="src\Camera.h" />
<ClInclude Include="src\Chunk.h" /> <ClInclude Include="src\Chunk.h" />
<ClInclude Include="src\NoiseSettings.h" />
<ClInclude Include="src\Planet.h" /> <ClInclude Include="src\Planet.h" />
<ClInclude Include="src\Shader.h" /> <ClInclude Include="src\Shader.h" />
<ClInclude Include="vendor\imgui\imconfig.h" /> <ClInclude Include="vendor\imgui\imconfig.h" />

6
ScuffedMinecraft/ScuffedMinecraft.vcxproj.filters
View File

@ -66,6 +66,9 @@
<ClCompile Include="vendor\imgui\imgui_widgets.cpp"> <ClCompile Include="vendor\imgui\imgui_widgets.cpp">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\NoiseSettings.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="src\Shader.h"> <ClInclude Include="src\Shader.h">
@ -119,6 +122,9 @@
<ClInclude Include="vendor\imgui\imstb_truetype.h"> <ClInclude Include="vendor\imgui\imstb_truetype.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\NoiseSettings.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<None Include="assets\shaders\vertex_shader.glsl" /> <None Include="assets\shaders\vertex_shader.glsl" />

13
ScuffedMinecraft/assets/shaders/fragment_shader.glsl
View File

@ -1,12 +1,23 @@
#version 330 core #version 330 core
in vec2 TexCoord; in vec2 TexCoord;
in vec3 Normal;
out vec4 FragColor; out vec4 FragColor;
uniform sampler2D tex; uniform sampler2D tex;
vec3 ambient = vec3(.5);
vec3 lightDirection = vec3(0.8, 1, 0.7);
void main() void main()
{ {
FragColor = texture(tex, TexCoord); vec3 lightDir = normalize(-lightDirection);
float diff = max(dot(Normal, lightDir), 0.0);
vec3 diffuse = diff * vec3(1);
vec4 result = vec4(ambient + diffuse, 1.0);
FragColor = texture(tex, TexCoord) * result;
} }

15
ScuffedMinecraft/assets/shaders/vertex_shader.glsl
View File

@ -1,9 +1,12 @@
#version 330 core #version 330 core
layout (location = 0) in vec3 aPos; layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord; layout (location = 1) in vec2 aTexCoord;
layout (location = 2) in int aDirection;
out vec2 TexCoord; out vec2 TexCoord;
out vec3 Normal;
uniform float texMultiplier; uniform float texMultiplier;
@ -11,8 +14,20 @@ uniform mat4 model;
uniform mat4 view; uniform mat4 view;
uniform mat4 projection; uniform mat4 projection;
// Array of possible normals based on direction
const vec3 normals[6] = vec3[6](
vec3(0, 0, 1), // 0
vec3(0, 0, -1), // 1
vec3(1, 0, 0), // 2
vec3(-1, 0, 0), // 3
vec3(0, 1, 0), // 4
vec3(0, -1, 0) // 5
);
void main() void main()
{ {
gl_Position = projection * view * model * vec4(aPos, 1.0); gl_Position = projection * view * model * vec4(aPos, 1.0);
TexCoord = aTexCoord * texMultiplier; TexCoord = aTexCoord * texMultiplier;
Normal = normals[aDirection];
} }

4
ScuffedMinecraft/src/Application.cpp
View File

@ -52,8 +52,8 @@ int main()
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Create window // Create window
GLFWwindow* window = glfwCreateWindow(windowX, windowY, "Scuffed Minecraft", NULL, NULL); GLFWwindow* window = glfwCreateWindow(windowX, windowY, "Scuffed Minecraft", nullptr, nullptr);
if (window == NULL) if (window == nullptr)
{ {
std::cout << "Failed to create GLFW window\n"; std::cout << "Failed to create GLFW window\n";
glfwTerminate(); glfwTerminate();

56
ScuffedMinecraft/src/Chunk.cpp
View File

@ -44,12 +44,6 @@ void Chunk::GenerateChunk()
WorldGen::GenerateChunkData(chunkPos.x - 1, chunkPos.y, chunkPos.z, chunkSize, &westData); WorldGen::GenerateChunkData(chunkPos.x - 1, chunkPos.y, chunkPos.z, chunkSize, &westData);
WorldGen::GenerateChunkData(chunkPos.x, chunkPos.y + 1, chunkPos.z, chunkSize, &upData); WorldGen::GenerateChunkData(chunkPos.x, chunkPos.y + 1, chunkPos.z, chunkSize, &upData);
WorldGen::GenerateChunkData(chunkPos.x, chunkPos.y - 1, chunkPos.z, chunkSize, &downData); WorldGen::GenerateChunkData(chunkPos.x, chunkPos.y - 1, chunkPos.z, chunkSize, &downData);
//auto northData = Planet::planet->GetChunkData(chunkPos.x, chunkPos.y, chunkPos.z - 1);
//auto southData = Planet::planet->GetChunkData(chunkPos.x, chunkPos.y, chunkPos.z + 1);
//auto eastData = Planet::planet->GetChunkData(chunkPos.x + 1, chunkPos.y, chunkPos.z);
//auto westData = Planet::planet->GetChunkData(chunkPos.x - 1, chunkPos.y, chunkPos.z);
//auto upData = Planet::planet->GetChunkData(chunkPos.x, chunkPos.y + 1, chunkPos.z);
//auto downData = Planet::planet->GetChunkData(chunkPos.x, chunkPos.y - 1, chunkPos.z);
//std::cout << "Got chunk data in thread: " << std::this_thread::get_id() << '\n'; //std::cout << "Got chunk data in thread: " << std::this_thread::get_id() << '\n';
@ -82,10 +76,10 @@ void Chunk::GenerateChunk()
if (northBlock == 0) if (northBlock == 0)
{ {
vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->sideMinX, block->sideMinY)); vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->sideMinX, block->sideMinY, 0));
vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->sideMaxX, block->sideMinY)); vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->sideMaxX, block->sideMinY, 0));
vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->sideMinX, block->sideMaxY)); vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->sideMinX, block->sideMaxY, 0));
vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->sideMaxX, block->sideMaxY)); vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->sideMaxX, block->sideMaxY, 0));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -112,10 +106,10 @@ void Chunk::GenerateChunk()
} }
if (southBlock == 0) if (southBlock == 0)
{ {
vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->sideMinX, block->sideMinY)); vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->sideMinX, block->sideMinY, 1));
vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->sideMaxX, block->sideMinY)); vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->sideMaxX, block->sideMinY, 1));
vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->sideMinX, block->sideMaxY)); vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->sideMinX, block->sideMaxY, 1));
vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->sideMaxX, block->sideMaxY)); vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->sideMaxX, block->sideMaxY, 1));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -142,10 +136,10 @@ void Chunk::GenerateChunk()
} }
if (westBlock == 0) if (westBlock == 0)
{ {
vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->sideMinX, block->sideMinY)); vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->sideMinX, block->sideMinY, 2));
vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->sideMaxX, block->sideMinY)); vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->sideMaxX, block->sideMinY, 2));
vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->sideMinX, block->sideMaxY)); vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->sideMinX, block->sideMaxY, 2));
vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->sideMaxX, block->sideMaxY)); vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->sideMaxX, block->sideMaxY, 2));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -172,10 +166,10 @@ void Chunk::GenerateChunk()
} }
if (eastBlock == 0) if (eastBlock == 0)
{ {
vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->sideMinX, block->sideMinY)); vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->sideMinX, block->sideMinY, 3));
vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->sideMaxX, block->sideMinY)); vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->sideMaxX, block->sideMinY, 3));
vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->sideMinX, block->sideMaxY)); vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->sideMinX, block->sideMaxY, 3));
vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->sideMaxX, block->sideMaxY)); vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->sideMaxX, block->sideMaxY, 3));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -202,10 +196,10 @@ void Chunk::GenerateChunk()
} }
if (bottomBlock == 0) if (bottomBlock == 0)
{ {
vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->bottomMinX, block->bottomMinY)); vertices.push_back(Vertex(x + 1, y + 0, z + 1, block->bottomMinX, block->bottomMinY, 4));
vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->bottomMaxX, block->bottomMinY)); vertices.push_back(Vertex(x + 0, y + 0, z + 1, block->bottomMaxX, block->bottomMinY, 4));
vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->bottomMinX, block->bottomMaxY)); vertices.push_back(Vertex(x + 1, y + 0, z + 0, block->bottomMinX, block->bottomMaxY, 4));
vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->bottomMaxX, block->bottomMaxY)); vertices.push_back(Vertex(x + 0, y + 0, z + 0, block->bottomMaxX, block->bottomMaxY, 4));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -232,10 +226,10 @@ void Chunk::GenerateChunk()
} }
if (topBlock == 0) if (topBlock == 0)
{ {
vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->topMinX, block->topMinY)); vertices.push_back(Vertex(x + 0, y + 1, z + 1, block->topMinX, block->topMinY, 5));
vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->topMaxX, block->topMinY)); vertices.push_back(Vertex(x + 1, y + 1, z + 1, block->topMaxX, block->topMinY, 5));
vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->topMinX, block->topMaxY)); vertices.push_back(Vertex(x + 0, y + 1, z + 0, block->topMinX, block->topMaxY, 5));
vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->topMaxX, block->topMaxY)); vertices.push_back(Vertex(x + 1, y + 1, z + 0, block->topMaxX, block->topMaxY, 5));
indices.push_back(currentVertex + 0); indices.push_back(currentVertex + 0);
indices.push_back(currentVertex + 3); indices.push_back(currentVertex + 3);
@ -276,6 +270,8 @@ void Chunk::Render(unsigned int modelLoc)
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_BYTE, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texGridX)); glVertexAttribPointer(1, 2, GL_BYTE, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texGridX));
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glVertexAttribIPointer(2, 1, GL_BYTE, sizeof(Vertex), (void*)offsetof(Vertex, direction));
glEnableVertexAttribArray(2);
glGenBuffers(1, &ebo); glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);

5
ScuffedMinecraft/src/Chunk.h
View File

@ -8,8 +8,9 @@ struct Vertex
{ {
char posX, posY, posZ; char posX, posY, posZ;
char texGridX, texGridY; char texGridX, texGridY;
char direction;
Vertex(char _posX, char _posY, char _posZ, char _texGridX, char _texGridY) Vertex(char _posX, char _posY, char _posZ, char _texGridX, char _texGridY, char _direction)
{ {
posX = _posX; posX = _posX;
posY = _posY; posY = _posY;
@ -17,6 +18,8 @@ struct Vertex
texGridX = _texGridX; texGridX = _texGridX;
texGridY = _texGridY; texGridY = _texGridY;
direction = _direction;
} }
}; };

18
ScuffedMinecraft/src/NoiseSettings.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "NoiseSettings.h"
NoiseSettings::NoiseSettings(float _frequency, float _amplitude, float _offset)
: frequency(_frequency), amplitude(_amplitude), offset(_offset), chance(0), block(0)
{
}
NoiseSettings::NoiseSettings(float _frequency, float _amplitude, float _offset, float _chance, unsigned int _block, int _maxHeight)
: frequency(_frequency), amplitude(_amplitude), offset(_offset), chance(_chance), block(_block), maxHeight(_maxHeight)
{
}
NoiseSettings::~NoiseSettings()
{
}

17
ScuffedMinecraft/src/NoiseSettings.h Normal file
View File

@ -0,0 +1,17 @@
#pragma once
struct NoiseSettings
{
public:
float amplitude;
float frequency;
float offset;
float chance;
unsigned int block;
int maxHeight;
NoiseSettings(float _frequency, float _amplitude, float _offset);
NoiseSettings(float _frequency, float _amplitude, float _offset, float _chance, unsigned int _block, int _maxHeight);
~NoiseSettings();
};

64
ScuffedMinecraft/src/Planet.cpp
View File

@ -55,17 +55,17 @@ void Planet::Update(float camX, float camY, float camZ, unsigned int modelLoc)
// Add middle chunks // Add middle chunks
for (int y = 0; y <= renderHeight; y++) for (int y = 0; y <= renderHeight; y++)
{ {
chunkQueue.push({ camChunkX, y, camChunkZ + r }); chunkQueue.push({ camChunkX, camChunkY + y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, y, camChunkZ }); chunkQueue.push({ camChunkX + r, camChunkY + y, camChunkZ });
chunkQueue.push({ camChunkX, y, camChunkZ - r }); chunkQueue.push({ camChunkX, camChunkY + y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, y, camChunkZ }); chunkQueue.push({ camChunkX - r, camChunkY + y, camChunkZ });
if (y > 0) if (y > 0)
{ {
chunkQueue.push({ camChunkX, -y, camChunkZ + r }); chunkQueue.push({ camChunkX, camChunkY - y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, -y, camChunkZ }); chunkQueue.push({ camChunkX + r, camChunkY - y, camChunkZ });
chunkQueue.push({ camChunkX, -y, camChunkZ - r }); chunkQueue.push({ camChunkX, camChunkY - y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, -y, camChunkZ }); chunkQueue.push({ camChunkX - r, camChunkY - y, camChunkZ });
} }
} }
@ -74,31 +74,31 @@ void Planet::Update(float camX, float camY, float camZ, unsigned int modelLoc)
{ {
for (int y = 0; y <= renderHeight; y++) for (int y = 0; y <= renderHeight; y++)
{ {
chunkQueue.push({ camChunkX + e, y, camChunkZ + r }); chunkQueue.push({ camChunkX + e, camChunkY + y, camChunkZ + r });
chunkQueue.push({ camChunkX - e, y, camChunkZ + r }); chunkQueue.push({ camChunkX - e, camChunkY + y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, y, camChunkZ + e }); chunkQueue.push({ camChunkX + r, camChunkY + y, camChunkZ + e });
chunkQueue.push({ camChunkX + r, y, camChunkZ - e }); chunkQueue.push({ camChunkX + r, camChunkY + y, camChunkZ - e });
chunkQueue.push({ camChunkX + e, y, camChunkZ - r }); chunkQueue.push({ camChunkX + e, camChunkY + y, camChunkZ - r });
chunkQueue.push({ camChunkX - e, y, camChunkZ - r }); chunkQueue.push({ camChunkX - e, camChunkY + y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, y, camChunkZ + e }); chunkQueue.push({ camChunkX - r, camChunkY + y, camChunkZ + e });
chunkQueue.push({ camChunkX - r, y, camChunkZ - e }); chunkQueue.push({ camChunkX - r, camChunkY + y, camChunkZ - e });
if (y > 0) if (y > 0)
{ {
chunkQueue.push({ camChunkX + e, -y, camChunkZ + r }); chunkQueue.push({ camChunkX + e, camChunkY - y, camChunkZ + r });
chunkQueue.push({ camChunkX - e, -y, camChunkZ + r }); chunkQueue.push({ camChunkX - e, camChunkY - y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, -y, camChunkZ + e }); chunkQueue.push({ camChunkX + r, camChunkY - y, camChunkZ + e });
chunkQueue.push({ camChunkX + r, -y, camChunkZ - e }); chunkQueue.push({ camChunkX + r, camChunkY - y, camChunkZ - e });
chunkQueue.push({ camChunkX + e, -y, camChunkZ - r }); chunkQueue.push({ camChunkX + e, camChunkY - y, camChunkZ - r });
chunkQueue.push({ camChunkX - e, -y, camChunkZ - r }); chunkQueue.push({ camChunkX - e, camChunkY - y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, -y, camChunkZ + e }); chunkQueue.push({ camChunkX - r, camChunkY - y, camChunkZ + e });
chunkQueue.push({ camChunkX - r, -y, camChunkZ - e }); chunkQueue.push({ camChunkX - r, camChunkY - y, camChunkZ - e });
} }
} }
} }
@ -106,17 +106,17 @@ void Planet::Update(float camX, float camY, float camZ, unsigned int modelLoc)
// Add corners // Add corners
for (int y = 0; y <= renderHeight; y++) for (int y = 0; y <= renderHeight; y++)
{ {
chunkQueue.push({ camChunkX + r, y, camChunkZ + r }); chunkQueue.push({ camChunkX + r, camChunkY + y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, y, camChunkZ - r }); chunkQueue.push({ camChunkX + r, camChunkY + y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, y, camChunkZ + r }); chunkQueue.push({ camChunkX - r, camChunkY + y, camChunkZ + r });
chunkQueue.push({ camChunkX - r, y, camChunkZ - r }); chunkQueue.push({ camChunkX - r, camChunkY + y, camChunkZ - r });
if (y > 0) if (y > 0)
{ {
chunkQueue.push({ camChunkX + r, -y, camChunkZ + r }); chunkQueue.push({ camChunkX + r, camChunkY - y, camChunkZ + r });
chunkQueue.push({ camChunkX + r, -y, camChunkZ - r }); chunkQueue.push({ camChunkX + r, camChunkY - y, camChunkZ - r });
chunkQueue.push({ camChunkX - r, -y, camChunkZ + r }); chunkQueue.push({ camChunkX - r, camChunkY - y, camChunkZ + r });
chunkQueue.push({ camChunkX - r, -y, camChunkZ - r }); chunkQueue.push({ camChunkX - r, camChunkY - y, camChunkZ - r });
} }
} }
} }

10
ScuffedMinecraft/src/Shader.cpp
View File

@ -46,25 +46,25 @@ Shader::Shader(const char* vertexPath, const char* fragmentPath)
// vertex shader // vertex shader
vertex = glCreateShader(GL_VERTEX_SHADER); vertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex, 1, &vShaderCode, NULL); glShaderSource(vertex, 1, &vShaderCode, nullptr);
glCompileShader(vertex); glCompileShader(vertex);
// print compile errors if any // print compile errors if any
glGetShaderiv(vertex, GL_COMPILE_STATUS, &success); glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);
if (!success) if (!success)
{ {
glGetShaderInfoLog(vertex, 512, NULL, infoLog); glGetShaderInfoLog(vertex, 512, nullptr, infoLog);
std::cout << "Error compiling vertex shader!\n" << infoLog << '\n'; std::cout << "Error compiling vertex shader!\n" << infoLog << '\n';
} }
// fragment shader // fragment shader
fragment = glCreateShader(GL_FRAGMENT_SHADER); fragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment, 1, &fShaderCode, NULL); glShaderSource(fragment, 1, &fShaderCode, nullptr);
glCompileShader(fragment); glCompileShader(fragment);
// print compile errors if any // print compile errors if any
glGetShaderiv(fragment, GL_COMPILE_STATUS, &success); glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);
if (!success) if (!success)
{ {
glGetShaderInfoLog(fragment, 512, NULL, infoLog); glGetShaderInfoLog(fragment, 512, nullptr, infoLog);
std::cout << "Error compiling fragment shader!\n" << infoLog << '\n'; std::cout << "Error compiling fragment shader!\n" << infoLog << '\n';
} }
@ -77,7 +77,7 @@ Shader::Shader(const char* vertexPath, const char* fragmentPath)
glGetProgramiv(ID, GL_LINK_STATUS, &success); glGetProgramiv(ID, GL_LINK_STATUS, &success);
if (!success) if (!success)
{ {
glGetProgramInfoLog(ID, 512, NULL, infoLog); glGetProgramInfoLog(ID, 512, nullptr, infoLog);
std::cout << "Error linking shader program!\n" << infoLog << '\n'; std::cout << "Error linking shader program!\n" << infoLog << '\n';
} }

108
ScuffedMinecraft/src/WorldGen.cpp
View File

@ -1,15 +1,37 @@
#include "WorldGen.h" #include "WorldGen.h"
#include <algorithm>
#include <OpenSimplexNoise.hh> #include <OpenSimplexNoise.hh>
#include "Blocks.h" #include "Blocks.h"
void WorldGen::GenerateChunkData(int chunkX, int chunkY, int chunkZ, int chunkSize, std::vector<unsigned int>* chunkData) void WorldGen::GenerateChunkData(int chunkX, int chunkY, int chunkZ, int chunkSize, std::vector<unsigned int>* chunkData)
{ {
// Init noise
OSN::Noise<2> noise2D;
OSN::Noise<3> noise3D;
// Init noise settings
NoiseSettings surfaceSettings[] {
{ 0.01f, 20.0f, 0 },
{ 0.1f, 3.0f, 0 }
};
int surfaceSettingsLength = sizeof(surfaceSettings) / sizeof(*surfaceSettings);
NoiseSettings caveSettings[] {
{ 0.05f, 1.0f, 0, .5f, 0, 100 }
};
int caveSettingsLength = sizeof(caveSettings) / sizeof(*caveSettings);
NoiseSettings oreSettings[] {
{ 0.075f, 1.0f, 8.54f, .75f, 1, 0 }
};
int oreSettingsLength = sizeof(oreSettings) / sizeof(*oreSettings);
// Set vector size
chunkData->reserve(chunkSize * chunkSize * chunkSize); chunkData->reserve(chunkSize * chunkSize * chunkSize);
OSN::Noise<2> surfaceNoise; // Account for chunk position
OSN::Noise<3> caveNoise;
int startX = chunkX * chunkSize; int startX = chunkX * chunkSize;
int startY = chunkY * chunkSize; int startY = chunkY * chunkSize;
int startZ = chunkZ * chunkSize; int startZ = chunkZ * chunkSize;
@ -18,36 +40,78 @@ void WorldGen::GenerateChunkData(int chunkX, int chunkY, int chunkZ, int chunkSi
{ {
for (int z = 0; z < chunkSize; z++) for (int z = 0; z < chunkSize; z++)
{ {
int noiseY = (surfaceNoise.eval((float)(x + startX) * .1f, (float)(z + startZ) * .1f) * 3.0f) + 20; // Surface noise
int noiseY = 20;
for (int i = 0; i < surfaceSettingsLength; i++)
{
noiseY += noise2D.eval(
(float)((x + startX) * surfaceSettings[i].frequency) + surfaceSettings[i].offset,
(float)((z + startZ) * surfaceSettings[i].frequency) + surfaceSettings[i].offset)
* surfaceSettings[i].amplitude;
}
for (int y = 0; y < chunkSize; y++) for (int y = 0; y < chunkSize; y++)
{ {
//chunkData.push_back(0); // Empty // Cave noise
//chunkData.push_back(1); // Full bool cave = false;
//chunkData.push_back(((x + y + z) % 2 == 0) ? 1 : 0); // Checkerboard for (int i = 0; i < caveSettingsLength; i++)
/*chunkData.push_back( // Edges {
(x == 0 || x == chunkSize - 1) || if (y + startY > caveSettings[i].maxHeight)
(y == 0 || y == chunkSize - 1) || continue;
(z == 0 || z == chunkSize - 1)
? 1 : 0
);*/
float noiseCaves = caveNoise.eval( float noiseCaves = noise3D.eval(
(float)(x + startX) * .1f, (float)((x + startX) * caveSettings[i].frequency) + caveSettings[i].offset,
(float)(y + startY) * .1f, (float)((y + startY) * caveSettings[i].frequency) + caveSettings[i].offset,
(float)(z + startZ) * .1f); (float)((z + startZ) * caveSettings[i].frequency) + caveSettings[i].offset)
* caveSettings[i].amplitude;
if (noiseCaves > caveSettings[i].chance)
{
cave = true;
break;
}
}
// Step 1: Terrain Shape (surface and caves) and Ores
// Sky and Caves // Sky and Caves
if (y + startY > noiseY) if (y + startY > noiseY)
chunkData->push_back(0); chunkData->push_back(0);
else if (noiseCaves > .5f) else if (cave)
chunkData->push_back(0); chunkData->push_back(0);
// Ground // Ground
else if (y + startY == noiseY)
chunkData->push_back(Blocks::GRASS_BLOCK);
else if (y + startY > 10)
chunkData->push_back(Blocks::DIRT_BLOCK);
else else
chunkData->push_back(Blocks::STONE_BLOCK); {
bool blockSet = false;
for (int i = 0; i < oreSettingsLength; i++)
{
if (y + startY > oreSettings[i].maxHeight)
continue;
float noiseOre = noise3D.eval(
(float)((x + startX) * oreSettings[i].frequency) + oreSettings[i].offset,
(float)((y + startY) * oreSettings[i].frequency) + oreSettings[i].offset,
(float)((z + startZ) * oreSettings[i].frequency) + oreSettings[i].offset)
* oreSettings[i].amplitude;
if (noiseOre > oreSettings[i].chance)
{
chunkData->push_back(oreSettings[i].block);
blockSet = true;
break;
}
}
if (!blockSet)
{
if (y + startY == noiseY)
chunkData->push_back(Blocks::GRASS_BLOCK);
else if (y + startY > 10)
chunkData->push_back(Blocks::DIRT_BLOCK);
else
chunkData->push_back(Blocks::STONE_BLOCK);
}
}
} }
} }
} }

1
ScuffedMinecraft/src/WorldGen.h
View File

@ -1,6 +1,7 @@
#pragma once #pragma once
#include <vector> #include <vector>
#include "NoiseSettings.h"
namespace WorldGen namespace WorldGen
{ {