mirror of https://github.com/AxioDL/metaforce.git
277 lines
9.0 KiB
C++
277 lines
9.0 KiB
C++
#include <boo/boo.hpp>
|
|
#include "logvisor/logvisor.hpp"
|
|
#include <athena/MemoryWriter.hpp>
|
|
#include "hecl/Runtime.hpp"
|
|
#include "hecl/HMDLMeta.hpp"
|
|
|
|
#include <math.h>
|
|
#include <thread>
|
|
#include <mutex>
|
|
#include <condition_variable>
|
|
|
|
namespace hecl
|
|
{
|
|
namespace Database
|
|
{
|
|
std::vector<const struct DataSpecEntry*> DATA_SPEC_REGISTRY;
|
|
}
|
|
}
|
|
|
|
struct HECLWindowCallback : boo::IWindowCallback
|
|
{
|
|
bool m_sizeDirty = false;
|
|
boo::SWindowRect m_latestSize;
|
|
void resized(const boo::SWindowRect& rect)
|
|
{
|
|
m_sizeDirty = true;
|
|
m_latestSize = rect;
|
|
}
|
|
|
|
bool m_destroyed = false;
|
|
void destroyed()
|
|
{
|
|
m_destroyed = true;
|
|
}
|
|
};
|
|
|
|
struct HECLApplicationCallback : boo::IApplicationCallback
|
|
{
|
|
HECLWindowCallback m_windowCb;
|
|
std::shared_ptr<boo::IWindow> m_mainWindow;
|
|
bool m_running = true;
|
|
|
|
int appMain(boo::IApplication* app)
|
|
{
|
|
/* Setup boo window */
|
|
m_mainWindow = app->newWindow(_S("HECL Test"), 1);
|
|
m_mainWindow->setCallback(&m_windowCb);
|
|
|
|
boo::ITextureR* renderTex = nullptr;
|
|
boo::IGraphicsBufferD* vubo = nullptr;
|
|
boo::IShaderDataBinding* binding = nullptr;
|
|
|
|
struct VertexUBO
|
|
{
|
|
float modelview[4][4] = {};
|
|
float modelviewInv[4][4] = {};
|
|
float projection[4][4] = {};
|
|
VertexUBO()
|
|
{
|
|
modelview[0][0] = 1.0;
|
|
modelview[1][1] = 1.0;
|
|
modelview[2][2] = 1.0;
|
|
modelview[3][3] = 1.0;
|
|
modelviewInv[0][0] = 1.0;
|
|
modelviewInv[1][1] = 1.0;
|
|
modelviewInv[2][2] = 1.0;
|
|
modelviewInv[3][3] = 1.0;
|
|
projection[0][0] = 1.0;
|
|
projection[1][1] = 1.0;
|
|
projection[2][2] = 1.0;
|
|
projection[3][3] = 1.0;
|
|
}
|
|
} vuboData;
|
|
|
|
std::mutex initmt;
|
|
std::condition_variable initcv;
|
|
std::mutex loadmt;
|
|
std::condition_variable loadcv;
|
|
std::unique_lock<std::mutex> outerLk(initmt);
|
|
std::thread loaderThr([&]()
|
|
{
|
|
std::unique_lock<std::mutex> innerLk(initmt);
|
|
boo::IGraphicsDataFactory* gfxF = m_mainWindow->getLoadContextDataFactory();
|
|
|
|
/* HECL managers */
|
|
hecl::Runtime::FileStoreManager fileMgr(app->getUniqueName());
|
|
hecl::Runtime::ShaderCacheManager shaderMgr(fileMgr, gfxF);
|
|
|
|
/* Compile HECL shader */
|
|
static std::string testShader = "HECLOpaque(Texture(0, UV(0)))";
|
|
//static std::string testShader = "HECLOpaque(vec4(1.0,1.0,1.0,1.0))";
|
|
hecl::Runtime::ShaderTag testShaderTag(testShader, 0, 1, 0, 0, 0, boo::Primitive::TriStrips,
|
|
hecl::Backend::ReflectionType::None, false, false, false);
|
|
std::shared_ptr<hecl::Runtime::ShaderPipelines> testShaderObj =
|
|
shaderMgr.buildShader(testShaderTag, testShader, "testShader", *gfxF);
|
|
|
|
boo::GraphicsDataToken data =
|
|
gfxF->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) -> bool
|
|
{
|
|
boo::SWindowRect mainWindowRect = m_mainWindow->getWindowFrame();
|
|
renderTex = ctx.newRenderTexture(mainWindowRect.size[0], mainWindowRect.size[1], false, false);
|
|
|
|
/* Generate meta structure (usually statically serialized) */
|
|
hecl::HMDLMeta testMeta;
|
|
testMeta.topology = hecl::HMDLTopology::TriStrips;
|
|
testMeta.vertStride = 32;
|
|
testMeta.vertCount = 4;
|
|
testMeta.indexCount = 4;
|
|
testMeta.colorCount = 0;
|
|
testMeta.uvCount = 1;
|
|
testMeta.weightCount = 0;
|
|
testMeta.bankCount = 0;
|
|
|
|
/* Binary form of meta structure */
|
|
atUint8 testMetaBuf[HECL_HMDL_META_SZ];
|
|
athena::io::MemoryWriter testMetaWriter(testMetaBuf, HECL_HMDL_META_SZ);
|
|
testMeta.write(testMetaWriter);
|
|
|
|
/* Make Tri-strip VBO */
|
|
struct Vert
|
|
{
|
|
float pos[3];
|
|
float norm[3];
|
|
float uv[2];
|
|
};
|
|
static const Vert quad[4] =
|
|
{
|
|
{{0.5,0.5},{},{1.0,1.0}},
|
|
{{-0.5,0.5},{},{0.0,1.0}},
|
|
{{0.5,-0.5},{},{1.0,0.0}},
|
|
{{-0.5,-0.5},{},{0.0,0.0}}
|
|
};
|
|
|
|
/* Now simple IBO */
|
|
static const uint32_t ibo[4] = {0,1,2,3};
|
|
|
|
/* Construct quad mesh against boo factory */
|
|
hecl::Runtime::HMDLData testData(ctx, testMetaBuf, quad, ibo);
|
|
|
|
/* Make ramp texture */
|
|
using Pixel = uint8_t[4];
|
|
static Pixel tex[256][256];
|
|
for (int i=0 ; i<256 ; ++i)
|
|
for (int j=0 ; j<256 ; ++j)
|
|
{
|
|
tex[i][j][0] = i;
|
|
tex[i][j][1] = j;
|
|
tex[i][j][2] = 0;
|
|
tex[i][j][3] = 0xff;
|
|
}
|
|
boo::ITexture* texture =
|
|
ctx.newStaticTexture(256, 256, 1, boo::TextureFormat::RGBA8, tex, 256*256*4);
|
|
|
|
/* Make vertex uniform buffer */
|
|
vubo = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(VertexUBO), 1);
|
|
|
|
/* Assemble data binding */
|
|
binding = testData.newShaderDataBindng(ctx, testShaderObj->m_pipelines[0], 1, (boo::IGraphicsBuffer**)&vubo, nullptr, 1, &texture);
|
|
return true;
|
|
});
|
|
|
|
/* Return control to main thread */
|
|
innerLk.unlock();
|
|
initcv.notify_one();
|
|
|
|
/* Wait for exit */
|
|
std::unique_lock<std::mutex> lk(loadmt);
|
|
while (m_running)
|
|
{
|
|
loadcv.wait(lk);
|
|
}
|
|
});
|
|
initcv.wait(outerLk);
|
|
|
|
m_mainWindow->showWindow();
|
|
m_windowCb.m_latestSize = m_mainWindow->getWindowFrame();
|
|
boo::IGraphicsCommandQueue* gfxQ = m_mainWindow->getCommandQueue();
|
|
m_mainWindow->getMainContextDataFactory();
|
|
|
|
size_t frameIdx = 0;
|
|
while (m_running)
|
|
{
|
|
m_mainWindow->waitForRetrace();
|
|
|
|
if (m_windowCb.m_destroyed)
|
|
{
|
|
m_running = false;
|
|
break;
|
|
}
|
|
|
|
if (m_windowCb.m_sizeDirty)
|
|
{
|
|
gfxQ->resizeRenderTexture(renderTex,
|
|
m_windowCb.m_latestSize.size[0],
|
|
m_windowCb.m_latestSize.size[1]);
|
|
m_windowCb.m_sizeDirty = false;
|
|
}
|
|
|
|
gfxQ->setRenderTarget(renderTex);
|
|
boo::SWindowRect r = m_windowCb.m_latestSize;
|
|
r.location[0] = 0;
|
|
r.location[1] = 0;
|
|
gfxQ->setViewport(r);
|
|
gfxQ->setScissor(r);
|
|
float rgba[] = {sinf(frameIdx / 60.0), cosf(frameIdx / 60.0), 0.0, 1.0};
|
|
gfxQ->setClearColor(rgba);
|
|
gfxQ->clearTarget();
|
|
|
|
vuboData.modelview[3][0] = sinf(frameIdx / 60.0) * 0.5;
|
|
vuboData.modelview[3][1] = cosf(frameIdx / 60.0) * 0.5;
|
|
vubo->load(&vuboData, sizeof(vuboData));
|
|
|
|
gfxQ->setShaderDataBinding(binding);
|
|
gfxQ->drawIndexed(0, 4);
|
|
gfxQ->resolveDisplay(renderTex);
|
|
gfxQ->execute();
|
|
|
|
++frameIdx;
|
|
}
|
|
|
|
std::unique_lock<std::mutex> finallk(loadmt);
|
|
finallk.unlock();
|
|
gfxQ->stopRenderer();
|
|
loadcv.notify_one();
|
|
loaderThr.join();
|
|
return 0;
|
|
}
|
|
void appQuitting(boo::IApplication* app)
|
|
{
|
|
m_running = false;
|
|
}
|
|
};
|
|
|
|
void AthenaExcHandler(athena::error::Level level,
|
|
const char* file, const char* function,
|
|
int line, const char* fmt, ...)
|
|
{
|
|
static logvisor::Module Log("heclTest::AthenaExcHandler");
|
|
va_list ap;
|
|
va_start(ap, fmt);
|
|
Log.reportSource(logvisor::Level(level), file, line, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
#if _WIN32
|
|
int wmain(int argc, const boo::SystemChar** argv)
|
|
#else
|
|
int main(int argc, const boo::SystemChar** argv)
|
|
#endif
|
|
{
|
|
atSetExceptionHandler(AthenaExcHandler);
|
|
logvisor::RegisterStandardExceptions();
|
|
logvisor::RegisterConsoleLogger();
|
|
HECLApplicationCallback appCb;
|
|
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto,
|
|
appCb, _S("heclTest"), _S("HECL Test"), argc, argv);
|
|
printf("IM DYING!!\n");
|
|
return ret;
|
|
}
|
|
|
|
#if _WIN32
|
|
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int)
|
|
{
|
|
int argc = 0;
|
|
const boo::SystemChar** argv = (const wchar_t**)(CommandLineToArgvW(lpCmdLine, &argc));
|
|
static boo::SystemChar selfPath[1024];
|
|
GetModuleFileNameW(nullptr, selfPath, 1024);
|
|
static const boo::SystemChar* booArgv[32] = {};
|
|
booArgv[0] = selfPath;
|
|
for (int i=0 ; i<argc ; ++i)
|
|
booArgv[i+1] = argv[i];
|
|
|
|
logvisor::CreateWin32Console();
|
|
return wmain(argc+1, booArgv);
|
|
}
|
|
#endif
|