// before render loop
    const unsigned int SHADOW_WIDTH = 1024, SHADOW_HEIGHT = 1024;
    unsigned int depthMapFBO;
    glGenFramebuffers(1, &depthMapFBO);
    // create depth cubemap texture
    unsigned int depthCubemap;
    glGenTextures(1, &depthCubemap);
    glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);
    for (unsigned int i = 0; i < 6; ++i)
        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_DEPTH_COMPONENT, SHADOW_WIDTH, SHADOW_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    // attach depth texture as FBO's depth buffer
    glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
    glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthCubemap, 0);
    glDrawBuffer(GL_NONE);
    glReadBuffer(GL_NONE);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);

    glm::vec3 lightPos = {2, 2, 2};

// inside update loop
float near_plane = 1.0f;
        float far_plane  = 25.0f;
        glm::mat4 shadowProj = glm::perspective(glm::radians(90.0f), (float)SHADOW_WIDTH / (float)SHADOW_HEIGHT, near_plane, far_plane);
        std::vector<glm::mat4> shadowTransforms;
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 1.0f,  0.0f,  0.0f), glm::vec3(0.0f, -1.0f,  0.0f)));
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3(-1.0f,  0.0f,  0.0f), glm::vec3(0.0f, -1.0f,  0.0f)));
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0f,  1.0f,  0.0f), glm::vec3(0.0f,  0.0f,  1.0f)));
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0f, -1.0f,  0.0f), glm::vec3(0.0f,  0.0f, -1.0f)));
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0f,  0.0f,  1.0f), glm::vec3(0.0f, -1.0f,  0.0f)));
        shadowTransforms.push_back(shadowProj * glm::lookAt(lightPos, lightPos + glm::vec3( 0.0f,  0.0f, -1.0f), glm::vec3(0.0f, -1.0f,  0.0f)));
        config::pointShadowMatrices = &shadowTransforms; // sets the vector

        glViewport(0, 0, SHADOW_WIDTH, SHADOW_HEIGHT);
        glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
        glClear(GL_DEPTH_BUFFER_BIT);
        glDisable(GL_CULL_FACE);

        glActiveTexture(GL_TEXTURE0 + config::pointShadowMapSlotStart);
        glBindTexture(GL_TEXTURE_CUBE_MAP, depthCubemap);

		// idea was that i could "layer" things later on but i haven't used that functionality yet, this just draws
		// the objects to the framebuffer.
        for (auto a : layerStack[0]->children) {
            a->pointDepthDraw();
        }

        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glEnable(GL_CULL_FACE);

// pointDepthDraw()

    pointLightDepthShader.use();
    for (int a = 0; a < 6; a++) {
        pointLightDepthShader.setUniformMat4f("shadowMatrices[" + std::to_string(a) + "]", config::pointShadowMatrices->at(a));
    }
    pointLightDepthShader.setUniformMat4f("model", model);
    pointLightDepthShader.setUniformf("farPlane", Light::pointLightFar);
    pointLightDepthShader.setUniform3f("lightPos", 2, 2, 2);


    glBindVertexArray(vertexArrayID);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
    glBindBuffer(GL_ARRAY_BUFFER, indexBufferID);

    if (indices.size() == 0) {
        glDrawArrays(GL_TRIANGLES, 0, vertices.size());
    }
    else {
        glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, nullptr);
    }

// shader code
// *NOTE, when i set the uniforms i had originally had GL_TRUE set to transpose them. i have a number of other shaders that
// i would have to fix if i were to swap back now, so thats why the order looks weird.*

//shader vertex
#version 430 core
layout (location = 0) in vec3 coord;

uniform mat4 model;

void main () {
    gl_Position = vec4(coord, 1.0) * (model);
}



//shader geometry
#version 430 core
layout (triangles) in;
layout (triangle_strip, max_vertices = 18) out;

uniform mat4 shadowMatrices[6];

out vec4 fragPosition;

void main () {
    for (int face = 0; face < 6; face++) {
        gl_Layer = face;
        for (int a = 0; a < 3; a++) {
            fragPosition = gl_in[a].gl_Position;
            gl_Position = fragPosition * shadowMatrices[face];
            EmitVertex();
        }
    }

    EndPrimitive();
}


//shader frag
#version 330 core
in vec4 fragPosition;

uniform vec3 lightPos;
uniform float farPlane;

void main()
{
    // get distance between fragment and light source
    float lightDistance = length(fragPosition.xyz - lightPos);

    // map to [0;1] range by dividing by far_plane
    lightDistance = lightDistance / farPlane;

    // write this as modified depth
    gl_FragDepth = lightDistance;