it works?

src/game/rendering/Rendering.cpp

@@ -0,0 +1,187 @@
+#include "Rendering.h"
+#include "../Log.h"
+#include "bgfx/defines.h"
+#include "bx/timer.h"
+#include <bx/file.h>
+#include <bgfx/bgfx.h>
+#include <bx/filepath.h>
+#include <bx/readerwriter.h>
+
+namespace Game
+{
+  static VertexData CubeVertices[] =
+  {
+  	{-1.0f,  1.0f,  1.0f, 0xff000000 },
+  	{ 1.0f,  1.0f,  1.0f, 0xff0000ff },
+  	{-1.0f, -1.0f,  1.0f, 0xff00ff00 },
+  	{ 1.0f, -1.0f,  1.0f, 0xff00ffff },
+  	{-1.0f,  1.0f, -1.0f, 0xffff0000 },
+  	{ 1.0f,  1.0f, -1.0f, 0xffff00ff },
+  	{-1.0f, -1.0f, -1.0f, 0xffffff00 },
+  	{ 1.0f, -1.0f, -1.0f, 0xffffffff },
+  };
+  
+  const uint16_t CubeIndices[] =
+  {
+  	0, 1, 2, // 0
+  	1, 3, 2,
+  	4, 6, 5, // 2
+  	5, 6, 7,
+  	0, 2, 4, // 4
+  	4, 2, 6,
+  	1, 5, 3, // 6
+  	5, 7, 3,
+  	0, 4, 1, // 8
+  	4, 5, 1,
+  	2, 3, 6, // 10
+  	6, 3, 7,
+  };
+  
+  namespace
+  {
+    
+    static const bgfx::Memory* loadMem(bx::FileReaderI* _reader, const bx::FilePath& _filePath)
+    {
+    	if (bx::open(_reader, _filePath) )
+    	{
+    		uint32_t size = (uint32_t)bx::getSize(_reader);
+    		const bgfx::Memory* mem = bgfx::alloc(size+1);
+    		bx::read(_reader, mem->data, size, bx::ErrorAssert{});
+    		bx::close(_reader);
+    		mem->data[mem->size-1] = '\0';
+    		return mem;
+    	}
+
+    	Log("Failed to load %s.", _filePath.getCPtr() );
+    	return NULL;
+    }
+    
+    bgfx::ShaderHandle LoadShader(const char* name)
+    {
+      bx::FilePath filePath{"game/compiled-shaders/"};
+      switch (bgfx::getRendererType())
+    	{
+    	case bgfx::RendererType::Noop:
+    	case bgfx::RendererType::Direct3D11:
+    	case bgfx::RendererType::Direct3D12: filePath.join("dx11");  break;
+    	case bgfx::RendererType::Agc:
+    	case bgfx::RendererType::Gnm:        filePath.join("pssl");  break;
+    	case bgfx::RendererType::Metal:      filePath.join("metal"); break;
+    	case bgfx::RendererType::Nvn:        filePath.join("nvn");   break;
+    	case bgfx::RendererType::OpenGL:     filePath.join("glsl");  break;
+    	case bgfx::RendererType::OpenGLES:   filePath.join("essl");  break;
+    	case bgfx::RendererType::Vulkan:     filePath.join("spirv"); break;
+
+    	case bgfx::RendererType::Count:
+    		BX_ASSERT(false, "You should not be here!");
+    		break;
+    	}
+
+    	char fileName[512]{0};
+    	bx::strCopy(fileName, sizeof(fileName), name);
+    	bx::strCat(fileName, sizeof(fileName), ".bin");
+    	filePath.join(fileName);
+
+      bx::FileReader fileReader;
+    	bgfx::ShaderHandle result = bgfx::createShader(loadMem(&fileReader, filePath.getCPtr()));
+    	return result;
+  	}
+  }
+  
+  void GameRendering::Setup(void* window)
+  {
+    bgfx::Init init;
+    init.type = bgfx::RendererType::OpenGL;
+    init.debug = true;
+    init.callback = &Callback;
+    init.platformData.nwh = (void*)window;
+    init.platformData.ndt = nullptr;
+    init.platformData.type = bgfx::NativeWindowHandleType::Default;
+    init.resolution.width = 1920;
+    init.resolution.height = 1080;
+    init.resolution.reset = BGFX_RESET_VSYNC;
+    if (!bgfx::init(init))
+    {
+      Log("BGFX setup failed!");
+    }
+    else
+    {
+      Log("BGFX setup succeded!");
+    }
+    bgfx::setDebug(BGFX_DEBUG_TEXT);
+    bgfx::setViewClear(0, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x303030ff, 1.0f, 0);
+
+    VertLayout.begin()
+      .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float)
+      .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true)
+      .end();
+
+    VertexBuffer = bgfx::createVertexBuffer(bgfx::makeRef(CubeVertices, sizeof(CubeVertices)), VertLayout);
+    IndexBuffer = bgfx::createIndexBuffer(bgfx::makeRef(CubeIndices, sizeof(CubeIndices)));
+    bgfx::ShaderHandle vertexShader = LoadShader("vert");
+    bgfx::ShaderHandle fragmentShader = LoadShader("frag");
+    bgfx::createProgram(vertexShader, fragmentShader, true);
+    State.StartTime = bx::getHPCounter();
+  }
+
+  void GameRendering::Update()
+  {
+    bgfx::setViewRect(0, 0, 0, State.WindowWidth, State.WindowHeight);
+
+  	const bx::Vec3 at  = { 0.0f, 0.0f,   0.0f };
+  	const bx::Vec3 eye = { 0.0f, 0.0f, -35.0f };
+
+  	// Set view and projection matrix for view 0.
+  	{
+  		float view[16];
+  		bx::mtxLookAt(view, eye, at);
+
+  		float proj[16];
+  		bx::mtxProj(proj, 60.0f, float(State.WindowWidth)/float(State.WindowHeight), 0.1f, 100.0f, bgfx::getCaps()->homogeneousDepth);
+  		bgfx::setViewTransform(0, view, proj);
+
+  		// Set view 0 default viewport.
+  		bgfx::setViewRect(0, 0, 0, State.WindowWidth, State.WindowHeight);
+  	}
+	  
+		// Set render states.
+		uint64_t state = 0
+			| BGFX_STATE_WRITE_RGB
+			| BGFX_STATE_WRITE_A
+			| BGFX_STATE_WRITE_Z
+			| BGFX_STATE_DEPTH_TEST_LESS
+   		| BGFX_STATE_CULL_CW
+			| BGFX_STATE_MSAA
+			;
+
+	  float time = (bx::getHPCounter() - State.StartTime) / (float)bx::getHPFrequency();
+  	for (int32_t i = 0; i < 11 * 11; ++i)
+  	{
+  	  uint32_t xx = i % 11;
+  	  uint32_t yy = i / 11;
+			float mtx[16];
+			bx::mtxRotateXY(mtx, time + xx*0.21f, time + yy*0.37f);
+			mtx[12] = -15.0f + float(xx)*3.0f;
+			mtx[13] = -15.0f + float(yy)*3.0f;
+			mtx[14] = 0.0f;
+
+			// Set model matrix for rendering.
+			bgfx::setTransform(mtx);
+
+			// Set vertex and index buffer.
+			bgfx::setVertexBuffer(0, VertexBuffer);
+			bgfx::setIndexBuffer(IndexBuffer);
+
+			bgfx::setState(state);
+			// Submit primitive for rendering to view 0.
+			bgfx::submit(0, Shader);
+		}
+    bgfx::dbgTextPrintf(1, 1, 0x0F, "Time: %f", time);
+    bgfx::frame();
+  }
+
+  void GameRendering::Shutdown()
+  {
+      bgfx::shutdown();
+  }
+}