New track: at the liqa sto

some hyperpop bullshit, idk
found a good ass vocal sample on preset share and i had to use it, here the fk it is, i like it, maybe ill do more of this


i fkn hate trap style drums but in this track it fit so well that i had no choice but to put trap drums on it,
in fact i absolutely hate "beat" type beats. you know what i fkn mean, those generic fuckass uncreative slop made by EVERY SINGLE PRODUCER ON THIS FUCKING EARTH
like cant you think of something else rather than making "lil dih" type beats? GOD I FKN HATE RAP BEATS OR HIP HOP BEATS, if youre gonna do shit like this then at least be creative, PLEASE.

on top of all, the audacity to even record that shit and put it on your story like youre so proud of making ABSOLUTE DOGSHIT, and then they act gangsta or whatever. nigga kill yourself for everyones sake.

New track: bGV0IG1lIGJlIG15c2VsZg==

something i made in a few hours,
sample that i used for vocals is "parasite" by cloudyfield

HELLO HAROLD

I FINALLY GOT A SHAPE ON MY FUCKING WINDOW



Sane engine is coming to life slowly, right now i just have a quad made out of two traingles,
WEEKS OF BLOOD SWEAT AND MORE SWEAT AND THEN TEARS FINALLY GAVE ITS' FRUITS OF LABOR

if you ask me what im trying to do with C++ and opengl suddenly, ill say i dont fucking know, but its nice to actually write code for once instead of just dragging the mouse around in unreal and blueprints

i stream my progress on twitch because thats the only place that has some people actually clicking, i fucking hate twitch but i do it anyways
i stream for myself, because im able to sit for hours when i feel like im talking to someone, and i understand shit better when i talk to myself
idfk what im saying, anyways

HELLO TRAINGLE + QUAD IS DONE MOTHERFUCKER AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

heres the source code idfk what anyone will do with it but it has good comments and explanantions imo

#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>


//	We need identifiers for functions just like how we need them with variables, thats why these two lines are here.
void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void ProcessInput(GLFWwindow* window);
void PrintOpenGLInfo();

//	A constant is a read-only variable, so the program cant change it.
//	SETTINGS
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;

//	We make a read-only var of type char, because OpenGL will be compiling the shader at run-time.
//	first we set the version of GLSL as 3.3 just like our OpenGL ver and we set the core profile.
//	"in" means input, and in this case our input variable is the vec3 var called aPos, and we set the location of this var as 0 using layout (location = 0)
//	gl_Position is the output of our vertex shader, so whatever we set it, that will be our output.
//	in this case we are straight up shooting the vec3 input into the output.
//	Vertex shader source code
const char* vertexShaderSource = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";

//	Frag shader only requires an output, we can declare output values with "out", in this case, of type vec4 named FragColor.
//	Fragment shader source code
const char* fragmentShaderSource = "#version 330 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"FragColor = vec4(1.0f, 0.2f, 0.5f, 1.0f);\n"
"}\n";

//	Right now, these vertices are stored on the CPU, we need to transfer them to our GPU.
//	Theres a variable called "GLfloat" which is the OpenGL ver of a float, but i dont find a reason why i should complicate shit.
float vertices[] =
{
//	  x		 y	   z	
	 0.5f, 0.5f, 0.0f,	//	top right point
	 0.5f, -0.5f, 0.0f,	//	bottom right point
	-0.5f, -0.5f, 0.0f,	//	bottom left point
	-0.5f,  0.5f, 0.0f	//	top left point
};

//	indices means indexes
unsigned int indices[] =
{
	0, 1, 3,	//	1st tri
	1, 2, 3		//	2nd tri
};


int main()
{
	glfwInit();
	//	We set the version of GLFW as 3.3 since that is the ver we are using
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

	//	We set the profile to core_profile which is the more flexible one rather than the
	//	deprecated immediate profile.
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	// The following line is for MacOS, uncomment if you are on mac (ew)
	// glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

	// we create a glfw window object called 'window' and set its' width height and name
	GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "Sane Engine", NULL, NULL);

	// Some error handling
	if (window == NULL)
	{
		std::cout << "Failed to create GLFW window" << std::endl;
		glfwTerminate();
		return -1;
	}

	// Make the context of our window the main context on the current thread
	// (yet to be understood)
	glfwMakeContextCurrent(window);
	//	Set appropriate size for the framebuffer according to the created window, we run this function everytime we resize the window as well.
	//	We run this once when the window is created to make sure the framebuffer is the same size as the glfw window
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

	//	Initialize/Prepare GLAD before calling any OpenGL function 
	//	(since GLAD manages the function pointers of OpenGL)
	//	glfwGetProcAddress gives us a correct OS-based function and we feed that into GLAD to load OpenGL func pointers
	if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
	{
		std::cout << "Failed to initialize GLAD" << std::endl;
		return -1;
	}

	//	get info about OpenGL and print it out
	//	This function doesnt exist in the book, this was added thanks to Mike Shah on yt
	PrintOpenGLInfo();



	//	VERTEX SHADER ::

	//	We create the shader object referencing a unique ID. 
	unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);

	//	Attach the shader object to the shader source
	//	First parameter of glShaderSource is the shader object we want to compile, second arg is how many strings we are passing in -which apparently is 1 string-
	//	Third arg is the shader source code we want to attach to the shader object, and the fourth arg can be ignored for now.
	glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);

	//	We finally compile the shader object that we attached a source code to it earlier.
	glCompileShader(vertexShader);

	//	Check for errors::
	//	define an int to indicate success
	int success;
	char infoLog[512];

	//	glGetShaderiv — Returns a parameter from a shader object
	//	1st arg is the shader object, 2nd arg is the status we want to return, 3rd arg is (yet to be understood)
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		//	Returns the information log for a shader object
		//	1st arg is the shader, 2nd is maxLength aka buffer size for our info log, 3rd arg returns the length of the string in infoLog
		//	4th is the character arrays to return the infoLog into aka the target to write to.
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
	}


	//	FRAGMENT SHADER ::

	//	We create the shader object referencing a unique ID. 
	unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

	//	Attach the shader object to the shader source
	//	First parameter of glShaderSource is the shader object we want to compile, second arg is how many strings we are passing in -which apparently is 1 string-
	//	Third arg is the shader source code we want to attach to the shader object, and the fourth arg can be ignored for now.
	glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);

	//	We finally compile the shader object that we attached a source code to it earlier.
	glCompileShader(fragmentShader);

	//	Check for compilation errors for the fragment shader.
	//	glGetShaderiv — Returns a parameter from a shader object
	//	1st arg is the shader object, 2nd arg is the status we want to return, 3rd arg is (yet to be understood)
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
	if (!success)
	{
		//	Returns the information log for a shader object
		//	1st arg is the shader, 2nd is maxLength aka buffer size for our info log, 3rd arg returns the length of the string in infoLog
		//	4th is the character arrays to return the infoLog into aka the target to write to.
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
	}

	//	SHADER PROGRAM ::

	//	Now that we have a vertex and fragment shader, we need to link both shader objects into a "shader program" and activate it so that we can use for rendering.
	//	when linking the shaders into a program, it links the outputs of one shader into the next shaders' inputs.
	//	so the linked shaders have to have matching ins and outs.

	//	Creation of the shader program object
	//	glCreateProgram creates a program, duh, and returns the ID of the program obj it created.
	unsigned int shaderProgram = glCreateProgram();

	//	we need to attach the shaders we compiled (vertex and fragment) to the shaderProgram we just created.
	glAttachShader(shaderProgram, vertexShader);
	glAttachShader(shaderProgram, fragmentShader);

	//	After we have attached the shaders to the shaderProgram, we need to link them using the following:
	glLinkProgram(shaderProgram);

	//	Checking for errors
	//	Since we arent checking a shader for errors, instead we are checking a program.
	//	So we use glGetProgramiv instead of glGetShaderiv that we used before,
	//	same thing with glGetShaderInfoLog that we used previously, now we need to use glGetProgramInfoLog.
	glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
	if (!success)
	{
		glGetShaderInfoLog(shaderProgram, 512, NULL, infoLog);
		std::cout << "ERROR::PROGRAM::SHADER::LINKING_FAILED\n" << infoLog << std::endl;
	}

	//	After we created the program and made sure the linking is working properly, we need to activate the program object.
	//	We can activate the shaderProgram by using it as an argument in glUseProgram function.
	//	Every shader and rendering call after glUseProgram will now use this program object (and thus the shaders).
	glUseProgram(shaderProgram);

	//	Once we have both shaders linked inside the shader program, we no longer need the vertexShader and fragmentShader
	//	To make some space, we delete them. Because they are already in the shader program itself.
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	//	TODO:	EXPLAIN EBO Element array buffer (page 38)



	//	decleration of our VBO, VAO & EBO, its of type int because it has a unique ID we need to pass in later.
	unsigned int VBO, VAO, EBO;

	//	glGenVertexArrays does what it seems like it does, instead of a buffer we create something that isnt a buffer (im sorry)
	glGenVertexArrays(1, &VAO);

	//	glGenBuffers allows us to generate a buffer for out vertex buffer objects(VBO) 
	//	Buffers have unique IDs, as well as VBO has a unique ID so we pass that into glGenBuffers to generate one.
	glGenBuffers(1, &VBO);


	//	generate another buffer for EBO
	glGenBuffers(1, &EBO);



	//	Unlike a Buffer, vertex arrays doesnt need specification for its type, its only one kind.
	glBindVertexArray(VAO);


	//	Since we want a VBO buffer, we need to bind the generated buffer to the appropriate type.
	//	After the generation of the needed buffer, we need to bind a type to it, we do this by writing the following:
	glBindBuffer(GL_ARRAY_BUFFER, VBO);

	//	Since VBO is GL_ARRAY_BUFFER now, we can fill this GL_ARRAY_BUFFER with the appropriate data. We do that using glBufferData.
	//	We feed the previously defined vertex data into the buffer's memory.
	//	First argument is the target buffer type, second arg is the size of the data we want to copy (in bytes), third arg is the data itself, fourth arg specifies how should the GPU manage the data
	//	Theres 3 types of ways the GPU manages the data; STREAM, STATIC and DYNAMIC draw.
	//	in this case we are using a STATIC draw, because we set the data once and we want to use it many times.
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);


	//	TODO: EXPLAIN
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);


	//	TODO: EXPLAIN
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);


	//	So far, we have sent the data we need to the GPU, and taught the GPU how it should process the data with the help of our vertex and fragment shaders.
	//	But we still need to make OpenGL understand what we want to do.
	//	We want to let OpenGL process this data in memory, and tell it how to connect the vertex data and its' attributes. (yet to be understood fully)

	//	glVertexAttribPointer, we can tell OpenGL how it should interpret the vertex data (per vertex attribute) 
	//	thanks to this func, we can set the vertex attributes pointers
	//	Our VBO holds 3 floats worth of data for each vertex point we specified before, since we set the location layout as 0
	//	then we tell glVertexAttribPointer func that we start at 0 (first arg), then we have to tell the function how many attributes we are about to specify,
	//	Since our vertices uses 3D dimensions then we use Vec3 which consists of 3 floats therefore 3 is our second arg.
	//	after that we tell what kind of data it is -> arg3 GL_FLOAT
	//	the 5th arg, is the space between each vertex attribute aka the stride, since we have 3 values for each vertex and each vertex is a float
	//	then we have to calculate the space needed for a single vertex, so we can tell how big of a step this function should take for the next vertex
	//	therefore we use 3 * sizeof(float) to calculate the space needed, in bytes. (a float occupies 4 bytes, and since we have 3 floats, then we need 12 bytes for each vertex = a stride)
	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);

	//	vertex attributes are disabled by default thats why we enable them
	//	0 is the index aka location of the attrib array to enable
	glEnableVertexAttribArray(0);



	//	UNBIND BUFFERS AND ARRAYS
	//	Now that we configured and modified our buffers and shit, we need to unbind it so we can use it later (in the render loop)
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);

	//	DONT UNBIND EBO (IMPIORTANT FOR SOME REASONS, IM SORRY IDK)
	//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);






	//	Right now, if you run this without the while loop, aka the render loop, it will just draw a single image and then quit immediately.
	//	with this render loop we make sure that it keeps drawing and handling user input until it is specifically told to stop.
	//	glfwWindowShouldClose checks if the GLFW window should close with each iteration of our render loop, duh. 
	//	Each iteration of a render loop is known as a "frame".

	//	RENDER LOOP::


	while (!glfwWindowShouldClose(window))
	{
		//	Check for inputs
		ProcessInput(window);

		//	Clean up the color of the frame to render the next frame replacing it with the specified RGBA in glClearColor.
		//	Not doing a glClear will result in vestiges of the previous frame to be present in the current frame, which might look cool in the future actually.
		glClearColor(0.0f, 0.4f, 0.5f, 1.0f);

		//	Set the state as glClearColor, and use that state in glClear, this is how all of OpenGL works. A big fucking state machine.
		//	TODO: (yet to be understood)
		glClear(GL_COLOR_BUFFER_BIT);


		//	use our shader program when we want to render an object
		glUseProgram(shaderProgram);

		//	Focus on the VAO that we modified before reaching the render loop
		glBindVertexArray(VAO);

		//	1st arg specifies what kind of primitive (shape) we want to draw,
		//	2nd arg is the amount of points we want to draw in total
		//	3rd arg is the type of the indices (indexes)
		//	4th arg is offset
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

		//	See page 22-23 in Learn OpenGL by Joey de Vries
		//	(yet to be understood)
		glfwSwapBuffers(window);

		//	This function checks if any events are triggered -like inputs-, updates the window state, and calls the corressponding functions.
		//	(which we can specify via callback methods like we did with the window resizing below.
		glfwPollEvents();
	}

	//	As soon as the render loop is complete it will terminate the glfw window and clean up all the resources to exit properly.
	glfwTerminate();
	return 0;
}

//	This function will be processing our inputs
void ProcessInput(GLFWwindow* window)
{
	//	Check if the ESCAPE key is PRESSed, if so then close the window.
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(window, true);
	}
}

//	This ensures that the viewport gets adjusted according to the window dimensions, so if the user resizes the window, itll fit itself inside there
//	"framebuffer_size_callback" takes a GLFWwindow object and two ints that indicates the new window dimensions.
//	This gets called everytime the window changes size. It also gets called when the window is first displayed.
void framebuffer_size_callback(GLFWwindow* window, int width, int height)
{
	//	Lastly, we tell OpenGL the dimensions of the viewport size, which is equal to the GLFW window size,
	//	and where it should be displayed.
	//	The first two values are the pixel locations of the lower left corner of the window, apparently thats the pivot point for created windows.
	//	Note that processed coordinates in OpenGL are between -1 and 1 so we effectively map from the range (-1 to 1) to (0, 800) and (0, 600).
	glViewport(0, 0, width, height);

	//	We register this function so GLFW would call it on every window resize
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
}

void PrintOpenGLInfo()
{
	std::cout << "Vendor: " << glGetString(GL_VENDOR) << std::endl;
	std::cout << "Renderer: " << glGetString(GL_RENDERER) << std::endl;
	std::cout << "Version: " << glGetString(GL_VERSION) << std::endl;
	std::cout << "Shading Language: " << glGetString(GL_SHADING_LANGUAGE_VERSION) << std::endl;
}