Fun times in world generation land!

After two hours of struggling with OpenGL texture coordinates, I now have a working texture atlas!

This looks awesome.
Being the huge fan of tower defenses (especially tower defense hybrids) that I am, I'm eager to see where this project goes.

[NOTE:]

Got two considerable things done today.

The first thing is fixing up and finalizing the chunk mesh building system. I created a diagram to help explain this:


NOTE: "tiles" are actually cubes/voxels, probably should have referred to them as such .

EDIT: Each dotted face represents a visible tile/voxel face.

This process essentially results in the mesh becoming the shell of the chunk. In the prototype I made for The Ascender, chunk building was done within each chunk, whereas in this version it's being handled in the world class. The reason for the switch is because beforehand invisible chunks and chunk borders were still being drawn because the system was not aware of adjacent chunks obsuring them. Now, only the visible tile/voxel faces of the visible chunks are being drawn.

I've heard of people using subdivision methods when constructing chunk meshes to cut down the amount of vertices, which is something I may consider doing later on, but for now, this works, so I'm not going to break it.

I'm much prouder of the second thing I accomplished today:


Basic directional lighting!

I know for you experienced OpenGL/GLSL programmers, this isn't much. But that's not what matters to me. What matters is the extremely annoying bug I ran into that took me hours to fix.

When building meshes, I store each piece of data into a std::vector, which is basically a dynamic array which you can add/remove data to. Right now I have three vectors for each VBO (which is like an attribute applied to each vertex of a mesh (ex. position of each vertex, color of each vertex, texture coordinates)), one for positions, one for texture coordinates, and one for normals. Case and point: I was storing the data for the normals into the position vector . That took me 2.5 hours to figure out. Oh well.

Up next: Texture altasing (different textures for different block types).

Got a basic terrain generator! Pretty hard to make out with this screenshot, though.

Currently working on a terrain generator based on a simplex noise implementation using some great public domain source code which you can download yourself here: www.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java

In a prototype I've made for this game, I've already ported this code over to C++ and implemented it, so implementing it here should be a piece of cake . Expect another update in a few minutes.

[Hello!]

Hello! At the moment (Jun 7 2018), The Ascender is more of a concept than a game, but I plan to change that!

I'm making this devlog to showcase my game as it progresses and to keep track of it myself. But let me tell you about what it is, or rather, what it's going to be.

The Ascender is going to be a Survival Sandbox game focused on defending a (or multiple) specific point(s) from hordes of enemies that spawn periodically. This game will draw heavy inspiration from mid-late '90s FPS games, and I'm thinking of incorperating some rougelike elements into certain other aspects of the game as well.

I'm not going to say too much on what the game is trying to be, (I wouldn't want to spoil it now, would i?   ) but as progress continues, more and more about the game will be revealed (obviously).

Until then, I'll leave you with the basic development information and some screenshots of the engine so far:

Language/Engine: C++
Graphics: OpenGL 3.3+
Libraries:
    - GLEW (provides modern OpenGL declarations)
    - GLFW (used for easy window creation and mouse/keyboard input)
    - GLM (provides math classes and utilities (vectors, matrices, etc.) [This would take forever to implement on it's own])
    - stb_image.h (texture decoder)


5x5x5 grid of chunks (game doesn't run this slow, I swear):

This looks neat already! Can't wait to see how it will turn out.