float findBlocker( sampler2D shadowMap,  vec2 uv, float zReceiver ) {
  poissonDiskSamples(uv);
  float texelSize = 1.0 / 2048.0;
  float blockDepth = 0.0;
  
  float radius =40.0;
  float bias = 0.005;
  int blockNum = 0;
  for (int i=0; i < BLOCKER_SEARCH_NUM_SAMPLES; i++) {
    float depth = unpack(texture2D(shadowMap, uv + poissonDisk[i] * texelSize * radius));
    if (depth < zReceiver - bias) {
      blockDepth += depth;
      blockNum += 1;
    }
  }
  if (blockNum == 0) {
    return 1.0;
  }
  blockDepth /= float(blockNum);

	return blockDepth;
}

float PCSS(sampler2D shadowMap, vec4 coords){
  poissonDiskSamples(coords.xy);
  float receiverDepth = coords.z;
  float LightSize =40.0;
  float texelSize = 1.0 / 2048.0;
  // STEP 1: avgblocker depth
  float blockDepth = findBlocker(shadowMap, coords.xy, receiverDepth);
  /*if (abs(blockDepth - receiverDepth) <0.010) {
    return -1.0;
  }*/
  // STEP 2: penumbra size
  float penumbraSize = (receiverDepth - blockDepth)  / blockDepth* LightSize;

  // STEP 3: filtering
  
  float shadow = 0.0;
  float bias = 0.005;
  for(int i =0; i <PCF_NUM_SAMPLES;i++) {
    float depth = unpack(texture2D(shadowMap, coords.xy + poissonDisk[i] * texelSize * penumbraSize));
    shadow += depth<receiverDepth - bias ? 0.0 : 1.0;
  }
  shadow = shadow/float(PCF_NUM_SAMPLES);
  return shadow;

}

half depth = Linear01Depth(tex2Dd(_CameraDepthTexture,i.uv))*_ProjectionParams.z;

float focusNear = _FocusDistance - _DepthOfField;
float focusFar = _FocusDistance + _DepthOfField;

half finnal_depth = 0;
if ((depth >= focusNear) && (depth <= focusFar));
else {
	if(depth < focusNear)
		finnal_depth = saturate(abs(focusNear - depth));
	if(depth > focusFar)
		finnal_depth = saturate(abs(depth - focusFar));
}

void OnRenderImage(RenderTexture src, RenderTexture dest) {
    {
        material.SetFloat("_DepthOfField", _DepthOfField);
        material.SetFloat("_FocusDistance", _FocusDistance);
        
        int width = (int)(src.width/ _DownSample);
        int height = (int)(src.height/ _DownSample);
        
        RenderTexture RT1 = RenderTexture.GetTemporary(width, height);
        RenderTexture RT2 = RenderTexture.GetTemporary(width, height);
        
        material.SetVector("_BlurOffset", new Vector4(_BlurRadius / wdith, _BlurRadius / height, 0, 0));
        Graphics.Blit(src,RT1,material,0);
        for (int i=0; i <_Iteration;i++){
            RenderTexture.ReleaseTemporary(RT2);
            width /= 2;
            height /= 2;
            RT2 = RenderTexture.GetTemporary(width, height);
            Graphics.Blit(RT1,RT2,material,0);
            
            RenderTexture.ReleaseTemporary(RT1);
            width /= 2;
            height /= 2;
            RT1 = RenderTexture.GetTemporary(width, height);
            Graphics.Blit(RT2,RT1,material,0);
        }
        
        for (int i=0; i <_Iteration;i++){
            RenderTexture.ReleaseTemporary(RT2);
            width *= 2;
            height *= 2;
            RT2 = RenderTexture.GetTemporary(width, height);
            Graphics.Blit(RT1,RT2,material,0);
            
            RenderTexture.ReleaseTemporary(RT1);
            width *= 2;
            height *= 2;
            RT1 = RenderTexture.GetTemporary(width, height);
            Graphics.Blit(RT2,RT1,material,0);
        }
        material.SetTexture("_BlurTex",RT1);
        Graphics.Blit(src,dest,material,1);
        RenderTexture.ReleaseTemporary(RT1);
        RenderTexture.ReleaseTemporary(RT2);
    }
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;


    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);


    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }
    
    /* Make the window's context current */
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);


    if (glewInit() != GLEW_OK)
        std::cout << "GlewInit fail!" << std::endl;


    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);

    Renderer renderer;

    // Setup Dear ImGui context
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGui::StyleColorsDark();

    // Setup Platform/Renderer backends
    ImGui_ImplGlfw_InitForOpenGL(window, true);
    ImGui_ImplOpenGL3_Init();

    while (!glfwWindowShouldClose(window))
    {
        renderer.Clear();
        ImGui_ImplOpenGL3_NewFrame();
        ImGui_ImplGlfw_NewFrame();
        ImGui::NewFrame();

        ImGui::Render();
        ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    //glDeleteProgram(shader);//有析构函数
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();

    glfwTerminate();
    return 0;
}

test::TestClearColor test;

while (!glfwWindowShouldClose(window))
{
    renderer.Clear();

    test.OnUpdate(0.0f);
    test.OnRender();

    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplGlfw_NewFrame();
    ImGui::NewFrame();

    test.OnImGuiRender();

    ImGui::Render();
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());


    glfwSwapBuffers(window);
    glfwPollEvents();
}

#pragma once

namespace test {

	class Test {
	public:
		Test() {}
		virtual ~Test() {}

		virtual void OnUpdate(float deltaTime) {}
		virtual void OnRender() {}
		virtual void OnImGuiRender() {}
	};
}

//TestClearColor.h
#pragma once

#include "Test.h"

namespace test {


	class TestClearColor : public Test {
	public:
		TestClearColor();
		~TestClearColor();

		void OnUpdate(float deltaTime) override;
		void OnRender() override;
		void OnImGuiRender() override;

	private:
		float m_ClearColor[4];

	};
}
//TestClearColor.cpp
#include "TestClearColor.h"
#include "Renderer.h"
#include "imgui/imgui.h"
namespace test {
	TestClearColor::TestClearColor() 
		: m_ClearColor {0.2f,0.3f,0.8f,1.0f} {
	}

	TestClearColor::~TestClearColor() {
	}

	void TestClearColor::OnUpdate(float deltaTime) {
	}

	void TestClearColor::OnRender() {
        GLCall(glClearColor(m_ClearColor[0],
                            m_ClearColor[1],m_ClearColor[2],m_ClearColor[3]));
		GLCall(glClear(GL_COLOR_BUFFER_BIT));
	}

	void TestClearColor::OnImGuiRender() {
		ImGui::ColorEdit4("Clear Color", m_ClearColor);
	}
}

#pragma once
#include <vector>
#include <functional>
#include <string>
#include <iostream>
namespace test {

	class Test {
	public:
		Test() {};
		virtual ~Test() {};

		virtual void OnUpdate(float deltaTime) {};
		virtual void OnRender() {};
		virtual void OnImGuiRender() {};
	};

	class TestMenu : public Test {
	public:
		TestMenu(Test*& currentTestPointer);

		//void OnUpdate(float deltaTime) override;
		//void OnRender() override;
		void OnImGuiRender() override;


		template<typename T>
		// 构造一个pari传入m_Tests中，分别是我们获得的名称和lambda，lambda的类型来自模板类型
		// lambda这里C++还没看过，以及function的标准函数也不太了解，到时候要去补一下C++这部分
		void RegisterTest(const std::string& name) {
			std::cout << "Registering test " << name << std::endl;
			m_Tests.push_back(std::make_pair(name, []() {return new T(); }));
		}
	private:
		Test*& m_CurrentTest;//我们的按钮会控制当前的Test, 把当前Test的引用传递到这里的成员指针

		
		// 我们并不想直接要一个test的指针，这样就代表这个实例已经被创建了
		// 而我们希望的是按下按钮，才创建和构造一个test的实例
		// 因此我们提供一个lambda的function，来构造一个test
		//vector储存一个pari，每个pari里有一个string表示Test的名称，function返回一个test的指针

		std::vector<std::pair<std::string, std::function<Test* ()>>> m_Tests;

	};
}

#include "Test.h"
#include "imgui/imgui.h"
namespace test {
    TestMenu::TestMenu(Test*& currentTestPointer) 
        : m_CurrentTest(currentTestPointer) {
    }

    void TestMenu::OnImGuiRender() {
        for (auto& test : m_Tests) {
            if (ImGui::Button(test.first.c_str()))
                m_CurrentTest = test.second();//按下按钮，则自动构造一个test实例，并把指针传递给m_CurrentTest
        }
    }

}

test::Test* currentTest = nullptr;
test::TestMenu* testMenu = new test::TestMenu(currentTest);
currentTest = testMenu;
//这样做的结果是，menu里的m_CurrentTest当前就储存的自己。
//因为我们没有必要每次都要设置一个初始的Test

//我们希望这样来设置Test，传入模板参数提供类型，以及对应的名称
//作者提出一种模块化coding的方式，就是先假装以及有这个功能，然后去使用，再回来实现
testMenu->RegisterTest<test::TestClearColor>("Clear Color");


while (!glfwWindowShouldClose(window))
{
    GLCall(glClearColor(0.0, 0.0f, 0.0f, 1.0f));
    renderer.Clear();

    ImGui_ImplOpenGL3_NewFrame();
    ImGui_ImplGlfw_NewFrame();
    ImGui::NewFrame();

    if (currentTest) {
        currentTest->OnUpdate(0.0f);
        currentTest->OnRender();
        ImGui::Begin("Test");
        if (currentTest != testMenu && ImGui::Button("<-")) {
            delete currentTest;
            currentTest = testMenu;
        }//删除当前Test后，回到testMenu
        currentTest->OnImGuiRender();
        ImGui::End();
    }

    ImGui::Render();
    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());


    glfwSwapBuffers(window);
    glfwPollEvents();
}
delete currentTest;//currentTest 的实例创建是模板的lambda里做的
if (currentTest != testMenu)
    delete testMenu;

GLCall(glClearColor(0.0, 0.0f, 0.0f, 1.0f));

delete currentTest;
if (currentTest != testMenu)
    delete testMenu;

#pragma once

#include "Test.h"
#include "VertexBuffer.h"
#include "VertexBufferLayout.h"
#include "Texture.h"

#include <memory>
namespace test {


	class TestTexture2D : public Test {
	public:
		TestTexture2D();
		~TestTexture2D();

		void OnUpdate(float deltaTime) override;
		void OnRender() override;
		void OnImGuiRender() override;

	private:
		std::unique_ptr<VertexArray> m_VAO;
		std::unique_ptr<IndexBuffer> m_IndexBuffer;
		std::unique_ptr<Shader> m_Shader;
		std::unique_ptr<Texture> m_Texture;
		std::unique_ptr<VertexBuffer> m_VertexBuffer;
		glm::mat4 m_Proj, m_View;
		glm::vec3 m_TranslationA, m_TranslationB;
	};
}

//
#include "TestTexture2D.h"
#include "Renderer.h"
#include "imgui/imgui.h"


#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"

namespace test {
	TestTexture2D::TestTexture2D() 
		: m_Proj(glm::ortho(-2.0f, 2.0f, -1.5f, 1.5f, -1.0f, 1.0f)),
		  m_View(glm::translate(glm::mat4(1.0f), glm::vec3(0, 0, 0))),
		m_TranslationA((0, 0,0)), m_TranslationB((0,0,0))
		 {



		float positions[16] = {
			-2.0f, -1.5f, 0.0f, 0.0f,
			 2.0f, -1.5f, 1.0f, 0.0f,
			 2.0f,  1.5f, 1.0f, 1.0f,
			-2.0f,  1.5f, 0.0f, 1.0f
				};
		unsigned int indices[] = {
			0,1,2,
			2,3,0
		};
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glEnable(GL_BLEND);

		

		m_VAO = std::make_unique<VertexArray>();
		m_VertexBuffer = std::make_unique<VertexBuffer>(positions, 4 * 4 * sizeof(float));
		VertexBufferLayout layout;
		layout.Push<float>(2);
		layout.Push<float>(2);
		m_VAO->AddBuffer(*m_VertexBuffer, layout);
		m_IndexBuffer = std::make_unique<IndexBuffer>(indices, 6);


		m_Shader = std::make_unique<Shader>("res/shaders/Basic.shader");
		m_Shader->Bind();
		m_Shader->SetUniform4f("u_Color", 0.8f, 0.3f, 0.8f, 1.0f);
		m_Texture = std::make_unique<Texture>("res/textures/2.png");
		m_Texture->Bind();
		m_Shader->SetUniform1i("u_Texture", 0);

	}

	TestTexture2D::~TestTexture2D() {
	}

	void TestTexture2D::OnUpdate(float deltaTime) {
	}

	void TestTexture2D::OnRender() {
		GLCall(glClearColor(0.0f,0.0f,0.0f,1.0f));
		GLCall(glClear(GL_COLOR_BUFFER_BIT));

		Renderer renderer;

		m_Texture->Bind();


		{
			glm::mat4 model = glm::translate(glm::mat4(1.0f), m_TranslationA);
			glm::mat4 mvp =m_Proj * m_View * model;
			m_Shader->Bind();
			m_Shader->SetUniformMat4f("u_MVP", mvp);
			renderer.Draw(*m_VAO, *m_IndexBuffer, *m_Shader);
		}

		{
			glm::mat4 model = glm::translate(glm::mat4(1.0f), m_TranslationB);
			glm::mat4 mvp = m_Proj * m_View * model;
			m_Shader->Bind();
			m_Shader->SetUniformMat4f("u_MVP", mvp);
			renderer.Draw(*m_VAO, *m_IndexBuffer, *m_Shader);
		}


	}

	void TestTexture2D::OnImGuiRender() {
		ImGui::SliderFloat3("Translation A", &m_TranslationA.x, 0.0f, 10.0f);
		ImGui::SliderFloat3("Translation B", &m_TranslationB.x, 0.0f, 10.0f);
		ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
	}
}

glBufferData(GL_ARRAY_BUFER,sizeof(vertices),vertices,GL_STATIC_DRAW)

struct Vertex{
	float Position[3];
    float Color[4];
    float TexCoords[2];
    float TexID;
};

glBufferData(GL_ARRAY_BUFER,1000*sizeof(Vertex),nullptr,GL_DYNAMIC_DRAW)

glEnableVertexArrayAttrib(m_QuadVB,0);
glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,sizeof(Vertex), (const void*)offsetof(Vertex, Position));
glEnableVertexArrayAttrib(m_QuadVB,1);
glVertexAttribPointer(1,4,GL_FLOAT,GL_FALSE,sizeof(Vertex), (const void*)offsetof(Vertex, Color));
//......

//Set dynamic buffer
//OnUpdate
//float vertices[] ={....};之后在这里我们每一帧都可能对顶点数据做出改变
//也可以用一些封装的方法
//这里作者也出现一个问题，就是前面Vertex的结构里定义的是数组，不能直接赋值一个结构，因此他改成了vec的结构
auto q0 = CreateQuad(-1.5f, -0.5f, 0.0f);//x,y,texID
auto q1 = CreateQuad(0.5f,-0.5f,1.0f);
Vertex vertices[8];
memcpy(vertices,q0.data(), q0.size()*sizeof(Vertex));
memcpy(vertices+q0.size(),q1.data(), q1.size()*sizeof(Vertex));

glBindBuffer(GL_ARRAY_BUFFER, m_QuadVB);
//glMapBuffer()我们可以用这个方法直接将数据写入缓冲
//也有glUnmapBuffer，把buffer从GPU上卸载下来
//但是这个方法会慢一点
glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(vertices),vertices);
//这个方法和glBufferData很像，但它不分配缓冲，仅仅是将数据放进去

//OnImGuiRender
ImGui::Begin("Controls");
ImGui::DragFloat2("Quad Pos",m_QuadPosition, 0.1f);
ImGui::End();

//OnUpdate
//...
//q0 = Create(m_QuadPosition[0],m_QuadPosition[1],0.0f);
//...

uint32_t indices[] = {
    0,1,2,2,3,0,
    4,5,6,6,7,4
};

const size_t MaxQuadCount = 1000;
//这既决定Vertex的数量，也决定indices的数量
const size_t MaxVertexCount = MaxQuadCount * 4;
const size_t MaxIndexCount = MaxQuadCount * 6;
//......
glBufferData(GL_ARRAY_BUFFER,sizeof(Vertex) * MaxVertexCount,nullptr,GL_DYNAMIC_DRAW);
//......
uint32_t indices[MaxIndexCount];
for (size_t i=0;i<MaxIndexCount;i+=6){
    indices[i+0]=0+offset;
    indices[i+1]=1+offset;
    indices[i+2]=2+offset;
    indices[i+3]=2+offset;
    indices[i+4]=3+offset;
    indices[i+5]=0+offset;
    
    offset += 4;
}

//Renderer.h

#pragma once

#include <GL/glew.h>

#include "VertexArray.h"
#include "IndexBuffer.h"

#include "Shader.h"

#define ASSERT(x) if (!(x)) __debugbreak();//MSVC function
#define GLCall(x) GLClearError();\
    x;\
	ASSERT(GLLogCall(#x, __FILE__, __LINE__))//#把x转换成字符串 
void GLClearError();
bool GLLogCall(const char* function, const char* file, int line);

class Renderer
{
private:
public:
	void Clear() const; 
	void Draw(const VertexArray& va, const IndexBuffer& ib, const Shader& shader) const;
	//vertex array, index buffer, shader
};

//Renderer.cpp

#include "Renderer.h"
#include <iostream>
void GLClearError() {
    while (glGetError() != GL_NO_ERROR);//!glGetError()
}
bool GLLogCall(const char* function, const char* file, int line) {//提供函数名与文件名以及行数
    while (GLenum error = glGetError()) {
        std::cout << "[OpenGL Error] (" << error << "): " << function <<
            " " << file << " : " << line << std::endl;
        return false;
    }
    return true;
}


void Renderer::Clear() const
{
    glClear(GL_COLOR_BUFFER_BIT);
}

void Renderer::Draw(const VertexArray& va, const IndexBuffer& ib, const Shader& shader) const
{
    shader.Bind();

    va.Bind();
    ib.Bind();
    GLCall(glDrawElements(GL_TRIANGLES, ib.GetCount(), GL_UNSIGNED_INT, nullptr));
}

while (!glfwWindowShouldClose(window))
{
    renderer.Clear();
    /* Render here */
    shader.Bind();
    shader.SetUniform4f("u_Color", r, 0.3f, 0.8f, 1.0f);
    renderer.Draw(va, ib, shader);
    
    if (r > 1.0f)
        increment = -0.05f;
    else if (r < 0.0f)
        increment = 0.05f;
    r += increment;
    /* Swap front and back buffers */
    glfwSwapBuffers(window);
    /* Poll for and process events */
    glfwPollEvents();
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

//Texture.h
#pragma once

#include "Renderer.h"

class Texture
{
private:
	unsigned int m_RendererID;
	std::string m_FilePath;
	unsigned char* m_LocalBuffer;
	int m_Width, m_Height, m_BPP;

public:
	Texture(const std::string& path);
	~Texture();

	void Bind(unsigned int slot = 0) const;
	void Unbind() const;
	// windows有32个 slot，移动平台如iphone有8个slot，这取决于GPU

	inline int GetWidth() const { return m_Width; }
	inline int GetHeight() const { return m_Height; }
};

//Texture.cpp
#include "Texture.h"
#include "vendor/stb_image/stb_image.h"


Texture::Texture(const std::string& path)
	: m_RendererID(0),	m_FilePath(path), 	m_LocalBuffer(nullptr), 
	m_Width(0),	m_Height(0), m_BPP(0)
{
	stbi_set_flip_vertically_on_load(1);
	//opengl希望pixel坐标从bottom-left开始
	//通常以扫描线的方式加载图片，左上角是起始点

	m_LocalBuffer = stbi_load(path.c_str(), &m_Width, &m_Height, &m_BPP, 4);

	GLCall(glGenTextures(1, &m_RendererID));
	GLCall(glBindTexture(GL_TEXTURE_2D, m_RendererID));

	GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
	GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
	GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
	GLCall(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));

	GLCall(glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Width, m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_LocalBuffer));
	
	GLCall(glBindTexture(GL_TEXTURE_2D, 0));

	if (m_LocalBuffer)
		stbi_image_free(m_LocalBuffer);
}

Texture::~Texture()
{
	glDeleteTextures(1, &m_RendererID);
}

void Texture::Bind(unsigned int slot) const
{
	glActiveTexture( GL_TEXTURE0 + slot);
	glBindTexture(GL_TEXTURE_2D, m_RendererID);
}

void Texture::Unbind() const
{
	glBindTexture(GL_TEXTURE_2D, 0);
}

void Shader::SetUniform1i(const std::string& name, int value)
{
    glUniform1i(GetUniformLocation(name), value);
}

 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Width, m_Height, 0, GL_RGBA8, GL_UNSIGNED_BYTE, m_LocalBuffer);
//对照教程，需要改成
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, m_Width, m_Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_LocalBuffer);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);

glm::mat4 proj = glm::ortho(-2.0f, 2.0f, -1.5f, 1.5f, -1.0f, 1.0f);
glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(-1, 0, 0));
glm::mat4 model = glm::translate(glm::mat4(1.0f), glm::vec3(2, 2, 0));

glm::mat4 mvp = proj * view * model;

// Modern desktop OpenGL doesn't have a standard portable header file to load OpenGL function pointers.
// Helper libraries are often used for this purpose! Here we are using our own minimal custom loader based on gl3w.
// In the rest of your app/engine, you can use another loader of your choice (gl3w, glew, glad, glbinding, glext, glLoadGen, etc.).
// If you happen to be developing a new feature for this backend (imgui_impl_opengl3.cpp):
// - You may need to regenerate imgui_impl_opengl3_loader.h to add new symbols. See https://github.com/dearimgui/gl3w_stripped
// - You can temporarily use an unstripped version. See https://github.com/dearimgui/gl3w_stripped/releases
// Changes to this backend using new APIs should be accompanied by a regenerated stripped loader version.
#define IMGL3W_IMPL
#include "imgui_impl_opengl3_loader.h"

#include "GL/glew.h"

// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls

// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsClassic();

// Setup Platform/Renderer backends
ImGui_ImplGlfw_InitForOpenGL(window, true);
ImGui_ImplOpenGL3_Init(glsl_version);

#include <imgui/imgui.h>
#include <imgui/imgui_impl_glfw.h>
#include <imgui/imgui_impl_opengl3.h>

    // Store GLSL version string so we can refer to it later in case we recreate shaders.
    // Note: GLSL version is NOT the same as GL version. Leave this to NULL if unsure.
    if (glsl_version == NULL)
    {
#if defined(IMGUI_IMPL_OPENGL_ES2)
        glsl_version = "#version 100";
#elif defined(IMGUI_IMPL_OPENGL_ES3)
        glsl_version = "#version 300 es";
#elif defined(__APPLE__)
        glsl_version = "#version 150";
#else
        glsl_version = "#version 130";

// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();

ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());

ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImGui::DestroyContext();

{
    static float f = 0.0f;
    static int counter = 0;

    ImGui::Begin("Hello, world!");                          // Create a window called "Hello, world!" and append into it.

    ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)
    ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
    ImGui::Checkbox("Another Window", &show_another_window);

    ImGui::SliderFloat("float", &f, 0.0f, 1.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
    ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color

    if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
        counter++;
    ImGui::SameLine();
    ImGui::Text("counter = %d", counter);

    ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
    ImGui::End();
}

glm::mat4 model = glm::translate(glm::mat4(1.0f), translation);
glm::mat4 mvp = proj * view * model;
//...
{
ImGui::Begin("Hello, world!");
ImGui::SliderFloat3("Translation", &translation.x, -2.0f, 2.0f);

ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::End();
}

shader.Bind();
va.Bind();
ib.Bind();
GLCall(glDrawElements(GL_TRIANGLES, ib.GetCount(), GL_UNSIGNED_INT, nullptr));