Browse Source

MeshViewer refactor is on good way

Reworked Primitive logic for scene rendering
FileUpdateTester works now .....
undefined
Benjamin ‘Touky’ Huet Sam Hocevar <sam@hocevar.net> 10 years ago
parent
commit
73f729d2ef
22 changed files with 462 additions and 161 deletions
  1. +13
    -15
      doc/samples/data/meshviewer.easymesh.lua
  2. +19
    -0
      doc/samples/data/meshviewer.init.lua
  3. +134
    -25
      doc/samples/meshviewer/meshviewer.cpp
  4. +34
    -8
      doc/samples/meshviewer/meshviewer.h
  5. +2
    -2
      doc/samples/meshviewer/meshviewer.vcxproj
  6. +14
    -0
      doc/samples/meshviewer/scenesetup.cpp
  7. +3
    -0
      doc/samples/meshviewer/scenesetup.h
  8. +21
    -2
      src/easymesh/easymeshlua.cpp
  9. +12
    -1
      src/easymesh/easymeshlua.h
  10. +5
    -0
      src/lol/gpu/indexbuffer.h
  11. +5
    -5
      src/lol/math/vector.h
  12. +18
    -7
      src/lolimgui.cpp
  13. +8
    -0
      src/lolimgui.h
  14. +40
    -9
      src/lolua/baselua.h
  15. +2
    -2
      src/mesh/mesh.cpp
  16. +8
    -2
      src/mesh/mesh.h
  17. +60
    -2
      src/mesh/primitive.cpp
  18. +4
    -5
      src/mesh/primitive.h
  19. +18
    -58
      src/scene.cpp
  20. +15
    -1
      src/scene.h
  21. +1
    -1
      src/sys/thread.cpp
  22. +26
    -16
      src/sys/threadtypes.cpp

+ 13
- 15
doc/samples/data/meshviewer.easymesh.lua View File

@@ -1,19 +1,17 @@
s0 = SceneSetup.New("DefaultSetup")
-- Gear 0: New style
em0 = EasyMesh.New("Mesh0");

s0:AddLight("Point")
s0:Position(0, 0, 15)
s0:Color("#bbb")
s0:AddLight("Directional")
s0:Position(0, 0, 15)
s0:Color("#bbb")
--addlight 1 position (3 10 0) color #444
em0:SetColor("#f00")
em0:AddBox(2)
em0:TranslateY(1.5)
em0:AddBox(2.5)

s0:Setup()
s0:Color("#ddd")
s0:Show("Gizmo")
s0:Show("Light")
-- Gear 1: New style
em1 = EasyMesh.New("Mesh1");

em1:SetColor("#0f0")
em1:AddBox(2.5)
em1:TranslateY(2)
em1:AddBox(2)

--SCENE SETUP END

--addlight 0.0 position (1 0 1) color #0ff
--addlight 0.0 position (-0.2 -1 -0.5) color (.0 .2 .5 1)

+ 19
- 0
doc/samples/data/meshviewer.init.lua View File

@@ -0,0 +1,19 @@
s0 = SceneSetup.New("DefaultSetup")

s0:AddLight("Point")
s0:Position(0, 0, 15)
s0:Color("#bbb")
s0:AddLight("Directional")
s0:Position(0, 0, 15)
s0:Color("#bbb")
--addlight 1 position (3 10 0) color #444

s0:Setup()
s0:Color("#ddd")
s0:Show("Gizmo")
s0:Show("Light")

--SCENE SETUP END

--addlight 0.0 position (1 0 1) color #0ff
--addlight 0.0 position (-0.2 -1 -0.5) color (.0 .2 .5 1)

+ 134
- 25
doc/samples/meshviewer/meshviewer.cpp View File

@@ -34,7 +34,7 @@ static int const TEXTURE_WIDTH = 256;
#define DEFAULT_HEIGHT (400.f * R_M)
#else
#define DEFAULT_WIDTH (1200.f * R_M)
#define DEFAULT_HEIGHT (400.f * R_M)
#define DEFAULT_HEIGHT (800.f * R_M)
#endif //HAS_WEB
#define WIDTH ((float)Video::GetSize().x)
#define HEIGHT ((float)Video::GetSize().y)
@@ -95,14 +95,26 @@ public:
array<vec3> m_targets;
};

//EasyMeshViewerObject --------------------------------------------------------
void EasyMeshViewerObject::TickDraw(float seconds, Scene &scene)
{
switch (m_mesh.GetMeshState().ToScalar())
{
case MeshRender::NeedConvert: { m_mesh.MeshConvert(); break; }
case MeshRender::CanRender: { scene.AddPrimitive(m_mesh, mat4::identity/*TODO:FIX THAT*/); break; }
default: break;
}
}

//EasyMeshLoadJob -------------------------------------------------------------
bool EasyMeshLoadJob::DoWork()
{
if (m_loader.ExecLuaFile(m_path))
map<String, EasyMeshLuaObject*> meshes;
if (m_loader.ExecLuaFile(m_path) && EasyMeshLuaLoader::GetRegisteredMeshes(meshes))
{
array<EasyMeshLuaObject*>& objs = m_loader.GetInstances();
for (EasyMeshLuaObject* obj : objs)
m_meshes << new EasyMeshViewerObject(obj->GetMesh());
array<String> keys = meshes.keys();
for (String key : keys)
m_meshes << new EasyMeshViewerObject(key, meshes[key]->GetMesh());
}
return !!m_meshes.count();
}
@@ -111,7 +123,7 @@ bool EasyMeshLoadJob::DoWork()
MeshViewerLoadJob* EasyMeshLoadJob::GetInstance(String const& path)
{
if (Check(path))
return new MeshViewerLoadJob(path);
return new EasyMeshLoadJob(path);
return nullptr;
}

@@ -126,11 +138,14 @@ void EasyMeshLoadJob::RetrieveResult(class MeshViewer* app)
//MeshViewer ------------------------------------------------------------------
MeshViewer::MeshViewer(char const *file_name)
: m_file_name(file_name)
{ }
{
LolImGui::Init();
}

//-----------------------------------------------------------------------------
MeshViewer::~MeshViewer()
{
LolImGui::Shutdown();
Stop();
}

@@ -140,26 +155,30 @@ void MeshViewer::Start()
/** OLD STUFF **/
//Prepare();

//Scene setup
m_setup_loader.ExecLuaFile("meshviewer_init.lua");

//Threads setup
m_entities << (m_file_check = new FileUpdateTester());
m_file_status = m_file_check->RegisterFile(m_file_name);
m_entities << (m_file_loader = new DefaultThreadManager(4, 0));

//Scene setup
m_ssetup_file_name = "data/meshviewer.init.lua";
UpdateSceneSetup();

//m_entities << (m_file_loader = new DefaultThreadManager(1, 1));
//Mesh file
m_file_status = m_file_check->RegisterFile(m_file_name);
m_file_loader->AddJob(GetLoadJob(m_file_name));

//Camera setup
m_camera = new Camera();
m_camera->SetView(vec3(0.f, 0.f, 10.f), vec3::zero, vec3::axis_y);
m_camera->SetProjection(0.f, .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);
m_camera->UseShift(true);
m_camera->SetView(vec3(10.f, 10.f, 10.f), vec3::zero, vec3::axis_y);
m_camera->SetProjection(40.f, .0001f, 2000.f);
//m_camera->SetProjection(90.f, .0001f, 2000.f, WIDTH * SCREEN_W, RATIO_HW);
//m_camera->UseShift(true);
g_scene->PushCamera(m_camera);

#if HAS_INPUT
InputProfile& ip = m_profile;
ip.AddBindings<MeshViewerKeyInput, MeshViewerKeyInput::KBD_BEG, MeshViewerKeyInput::KBD_END>(InputProfileType::Keyboard);
ip.AddBindings<MeshViewerKeyInput, MeshViewerKeyInput::MSE_BEG, MeshViewerKeyInput::MSE_END>(InputProfileType::Keyboard);
ip.AddBindings<MeshViewerKeyInput, MeshViewerKeyInput::MSE_BEG, MeshViewerKeyInput::MSE_END>(InputProfileType::MouseKey);

m_entities << (m_controller = new Controller("MeshViewer"));
m_controller->Init(m_profile);
@@ -179,9 +198,11 @@ void MeshViewer::Start()
//-----------------------------------------------------------------------------
void MeshViewer::Stop()
{
//Destroy scene setup
UpdateSceneSetup(true);

//Destroy core stuff
if (m_camera) g_scene->PopCamera(m_camera);
if (m_ssetup) delete m_ssetup;

m_file_check->UnregisterFile(m_file_status);

@@ -192,7 +213,6 @@ void MeshViewer::Stop()
while (m_objs.count()) delete m_objs.Pop();

//Nullify all
m_ssetup = nullptr;
m_camera = nullptr;
m_controller = nullptr;
m_file_check = nullptr;
@@ -202,6 +222,35 @@ void MeshViewer::Stop()
m_init = false;
}

//-----------------------------------------------------------------------------
void MeshViewer::UpdateSceneSetup(bool only_destroy)
{
//Delete previous setups
array<String> keys = m_ssetups.keys();
for (String key : keys)
delete m_ssetups[key];
m_ssetups.empty();
if (m_ssetup_file_status)
{
m_file_check->UnregisterFile(m_ssetup_file_status);
delete m_ssetup_file_status;
}
m_ssetup_file_status = nullptr;

//Init new setups
if (!only_destroy)
{
m_ssetup_loader.ExecLuaFile(m_ssetup_file_name);
if (m_ssetup_loader.GetLoadedSetups(m_ssetups))
{
m_ssetup_file_status = m_file_check->RegisterFile(m_ssetup_file_name);
array<String> keys = m_ssetups.keys();
if (!m_ssetup_name.count() || !keys.find(m_ssetup_name))
m_ssetup_name = keys[0];
}
}
}

//-----------------------------------------------------------------------------
MeshViewerLoadJob* MeshViewer::GetLoadJob(String const& path)
{
@@ -220,17 +269,67 @@ void MeshViewer::TickGame(float seconds)

m_first_tick = true;

//Check file update
ASSERT(m_file_status);
if (false && m_file_status->HasUpdated())
#if HAS_INPUT
{
//Shutdown logic
if (m_controller->IsKeyPressed(MeshViewerKeyInput::Exit))
Ticker::Shutdown();
}
#endif //HAS_INPUT

static bool default_open = true;
//static float fov = 40.f;
//static vec3 sphere_pos = vec3(20.f, 45.f, 45.f);
//static bool use_custom_cam = true;
//static float f;
//static int mesh_idx = 0;
//static array<char*> mesh_names_char;
//static array<String> mesh_names_str;

//Draw viewer objects
m_menu_mesh_names_char.empty();
m_menu_mesh_names_str.empty();
for (ViewerObject* obj : m_objs)
m_menu_mesh_names_str << obj->GetName();
for (ptrdiff_t i = 0; i < m_menu_mesh_names_str.count(); ++i)
m_menu_mesh_names_char << m_menu_mesh_names_str[i].C();

ImGuiIO& io = ImGui::GetIO();
ImGui::Begin("Camera Setup" /*, &default_open, ImGuiWindowFlags_AlwaysAutoResize*/);
{
ImGui::Text("Hello, world!");
ImGui::Checkbox("Use custom cam", &m_menu_cam_useage);
ImGui::Text("MousePos! %.2f/%.2f", io.MousePos.x, io.MousePos.y);
ImGui::Text("Left Mouse: %s", io.MouseDown[0] ? "true" : "false");
ImGui::SliderFloat("Cam FOV", &m_menu_cam_fov, 0.1f, 120.0f);
ImGui::SliderFloat("Cam Distance", &m_menu_cam_pos.x, 0.1f, 30.f);
ImGui::SliderFloat("Cam H-axis", &m_menu_cam_pos.y, -180.f, 180.f);
ImGui::SliderFloat("Cam V-axis", &m_menu_cam_pos.z, -89.f, 89.f);
ImGui::ListBox("Meshes", &m_menu_mesh_idx, (const char**)m_menu_mesh_names_char.data(), (int)m_menu_mesh_names_char.count());
//ImGui::ListBox()
}
ImGui::End();

//Camera
if (m_menu_cam_useage)
{
MeshViewerLoadJob* job = GetLoadJob(m_file_name);
if (!job)
m_file_loader->AddJob(job);
vec3 sphere_pos_rad = m_menu_cam_pos;
sphere_pos_rad.z = (sphere_pos_rad.z > 0.f) ? (90.f - sphere_pos_rad.z) : (sphere_pos_rad.z - 90.f);
sphere_pos_rad = vec3(sphere_pos_rad.x, radians(sphere_pos_rad.y), radians(sphere_pos_rad.z));
m_camera->SetFov(m_menu_cam_fov);
m_camera->SetPosition(cartesian(sphere_pos_rad));
m_camera->SetTarget(vec3::zero, vec3::axis_y);
}

//Check file update
ASSERT(m_file_status);
//if (false) //DEBUG
//m_file_status->GetTime()
if (m_file_status->HasUpdated())
m_file_loader->AddJob(GetLoadJob(m_file_name));

//Check work done
if (false)
//if (false) //DEBUG
{
array<ThreadJob*> result;
m_file_loader->GetWorkResult(result);
@@ -257,6 +356,16 @@ void MeshViewer::TickDraw(float seconds, Scene &scene)
{
super::TickDraw(seconds, scene);

//Draw viewer objects
if (m_menu_mesh_idx >= 0 && m_menu_mesh_idx < m_objs.count())
m_objs[m_menu_mesh_idx]->TickDraw(seconds, scene);

//Draw gizmos & grid
Debug::DrawGizmo(vec3::zero, vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.f);
Debug::DrawSetupColor(Color::white);
Debug::DrawSetupSegment(1.f);
Debug::DrawGrid(vec3::zero, vec3::axis_x, vec3::axis_y, vec3::axis_z, 10.f);

/** OLD STUFF **/
//Draw(seconds);
}


+ 34
- 8
doc/samples/meshviewer/meshviewer.h View File

@@ -131,31 +131,41 @@ class ViewerObject
{
public:
ViewerObject() { }
ViewerObject(String const& name) : m_name(name) { }
virtual ~ViewerObject() { }

virtual void TickDraw(float seconds, Scene &scene) { }
String GetName() { return m_name; }

protected:
String m_name;
};

//EasyMeshViewerObject --------------------------------------------------------
class EasyMeshViewerObject : public ViewerObject
{
typedef ViewerObject super;

public:
EasyMeshViewerObject()
: ViewerObject() { }
EasyMeshViewerObject(EasyMesh const& mesh)
: EasyMeshViewerObject()
EasyMeshViewerObject(String const& name, EasyMesh const& mesh)
: ViewerObject(name)
{
Init(mesh);
Init(name, mesh);
}
virtual ~EasyMeshViewerObject() { }

void Init(EasyMesh const& mesh)
virtual void TickDraw(float seconds, Scene &scene);

void Init(String const& name, EasyMesh const& mesh)
{
m_name = name;
m_mesh = mesh;
}

protected:
EasyMesh m_mesh;
EasyMesh m_mesh;
};

//MeshViewerLoadJob -----------------------------------------------------------
@@ -214,6 +224,8 @@ public:
void Start();
void Stop();

void UpdateSceneSetup(bool only_destroy = false);

MeshViewerLoadJob* GetLoadJob(String const& path);
void AddViewerObj(ViewerObject* obj) { m_objs << obj; }

@@ -238,9 +250,22 @@ private:
bool m_init = false;
bool m_first_tick = false;
InputProfile m_profile;
Camera * m_camera = nullptr;
SceneSetup* m_ssetup = nullptr;
SceneSetupLuaLoader m_setup_loader;
Camera* m_camera = nullptr;

//ImGui stuff
bool m_menu_cam_useage = true;
float m_menu_cam_fov = 40.f;
vec3 m_menu_cam_pos = vec3(20.f, 45.f, 45.f);
int m_menu_mesh_idx = 0;
array<char*> m_menu_mesh_names_char;
array<String> m_menu_mesh_names_str;

//Scene setup data
SceneSetupLuaLoader m_ssetup_loader;
FileUpdateStatus* m_ssetup_file_status = nullptr;
String m_ssetup_file_name;
String m_ssetup_name;
map<String, SceneSetup*> m_ssetups;

//File data
String m_file_name;
@@ -260,6 +285,7 @@ private:
DefaultThreadManager* m_file_loader = nullptr;

//OLD ---------------------------------------------------------------------
SceneSetup* m_ssetup = nullptr;
array<LightData> m_light_datas;
short m_input_usage;
mat4 m_mat;


+ 2
- 2
doc/samples/meshviewer/meshviewer.vcxproj View File

@@ -54,10 +54,10 @@
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
</None>
<None Include="data/meshviewer_init.lua">
<None Include="data\meshviewer.easymesh.lua">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
</None>
<None Include="data\meshviewer.easymesh.lua">
<None Include="data\meshviewer.init.lua">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
</None>
<None Include="meshviewer/meshviewer.index.html">


+ 14
- 0
doc/samples/meshviewer/scenesetup.cpp View File

@@ -299,4 +299,18 @@ void SceneSetupLuaLoader::RegisterSetup(SceneSetup* setup)
m_setups[setup->m_name] = setup;
}

//-----------------------------------------------------------------------------
bool SceneSetupLuaLoader::GetRegisteredSetups(map<String, SceneSetup*>& setups)
{
setups = m_setups;
return !!m_setups.count();
}

//-----------------------------------------------------------------------------
bool SceneSetupLuaLoader::GetLoadedSetups(map<String, SceneSetup*>& setups)
{
return GetRegisteredSetups(setups);
}


} /* namespace lol */

+ 3
- 0
doc/samples/meshviewer/scenesetup.h View File

@@ -161,6 +161,9 @@ public:
//-------------------------------------------------------------------------
protected:
static void RegisterSetup(SceneSetup* setup);
static bool GetRegisteredSetups(map<String, SceneSetup*>& setups);
public:
bool GetLoadedSetups(map<String, SceneSetup*>& setups);

private:
static map<String, SceneSetup*> m_setups;


+ 21
- 2
src/easymesh/easymeshlua.cpp View File

@@ -51,8 +51,24 @@ array<EasyMeshLuaObject*>& EasyMeshLuaLoader::GetInstances()
}

//-----------------------------------------------------------------------------
EasyMeshLuaObject::EasyMeshLuaObject() : LuaObject()
map<String, EasyMeshLuaObject*> EasyMeshLuaLoader::m_meshes;
void EasyMeshLuaLoader::RegisterMesh(EasyMeshLuaObject* mesh, String const& name)
{
m_meshes[name] = mesh;
}

//-----------------------------------------------------------------------------
bool EasyMeshLuaLoader::GetRegisteredMeshes(map<String, EasyMeshLuaObject*>& meshes)
{
meshes = m_meshes;
return !!m_meshes.count();
}

//-----------------------------------------------------------------------------
EasyMeshLuaObject::EasyMeshLuaObject(String const& name) : LuaObject()
{
if (!!name.count())
EasyMeshLuaLoader::RegisterMesh(this, name);
}

//-----------------------------------------------------------------------------
@@ -65,7 +81,10 @@ EasyMeshLuaObject* EasyMeshLuaObject::New(LuaState* l, int arg_nb)
{
UNUSED(l);
UNUSED(arg_nb);
return new EasyMeshLuaObject();
LuaStack s(l);
LuaString n("", true);
s >> n;
return new EasyMeshLuaObject(n());
}

//-----------------------------------------------------------------------------


+ 12
- 1
src/easymesh/easymeshlua.h View File

@@ -22,7 +22,7 @@ class EasyMeshLuaObject : public LuaObject
EasyMesh m_instance;
public:
//-------------------------------------------------------------------------
EasyMeshLuaObject();
EasyMeshLuaObject(String const& name);
virtual ~EasyMeshLuaObject();
EasyMesh& GetMesh() { return m_instance; }

@@ -645,12 +645,23 @@ public:
//-----------------------------------------------------------------------------
class EasyMeshLuaLoader : public LuaLoader
{
friend class EasyMeshLuaObject;

public:
EasyMeshLuaLoader();
virtual ~EasyMeshLuaLoader();
//Virtual Store lua object ------------------------------------------------
virtual void Store(LuaObject* obj);
array<EasyMeshLuaObject*>& GetInstances();

//-------------------------------------------------------------------------
protected:
static void RegisterMesh(EasyMeshLuaObject* mesh, String const& name);
public:
static bool GetRegisteredMeshes(map<String, EasyMeshLuaObject*>& meshes);

private:
static map<String, EasyMeshLuaObject*> m_meshes;
};

} /* namespace lol */

+ 5
- 0
src/lol/gpu/indexbuffer.h View File

@@ -22,6 +22,8 @@ namespace lol

class IndexBuffer
{
friend class Mesh;

public:
IndexBuffer(size_t size);
~IndexBuffer();
@@ -34,6 +36,9 @@ public:
void Bind();
void Unbind();

protected:
uint16_t *GetData();

private:
class IndexBufferData *m_data;
};


+ 5
- 5
src/lol/math/vector.h View File

@@ -1240,9 +1240,9 @@ template<typename T, int SWIZZLE>
static inline vec_t<T, 3> cartesian(vec_t<T, 3, SWIZZLE> const &a)
{
vec_t<T, 3> ret;
ret.x = a[0] * lol::sin(a[1]) * lol::cos(a[2]);
ret.y = a[0] * lol::sin(a[1]) * lol::sin(a[2]);
ret.z = a[0] * lol::cos(a[1]);
ret.x = a[0] * lol::sin(a[2]) * lol::cos(a[1]);
ret.y = a[0] * lol::cos(a[2]);
ret.z = a[0] * lol::sin(a[2]) * lol::sin(a[1]);
return ret;
}

@@ -1261,8 +1261,8 @@ static inline vec_t<T, 3> spherical(vec_t<T, 3, SWIZZLE> const &a)
{
vec_t<T, 3> ret;
ret[0] = sqlength(a);
ret[1] = lol::acos(a.z / ret[a.x]);
ret[2] = lol::atan(a.y / a.x);
ret[1] = lol::atan(a.y / a.x);
ret[2] = lol::acos(a.z / ret[0]);
return ret;
}



+ 18
- 7
src/lolimgui.cpp View File

@@ -96,7 +96,7 @@ LolImGui::~LolImGui()
delete m_vdecl;
}

//-------------------------------------------------------------------------
//-----------------------------------------------------------------------------
LolImGui* g_lolimgui = nullptr;
void LolImGui::Init()
{
@@ -147,7 +147,7 @@ void LolImGui::Shutdown()
ImGui::Shutdown();
}

//-------------------------------------------------------------------------
//-----------------------------------------------------------------------------
static String g_clipboard;
void LolImGui::SetClipboard(const char* text)
{
@@ -158,7 +158,7 @@ const char* LolImGui::GetClipboard()
return g_clipboard.C();
}

//-------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void LolImGui::TickGame(float seconds)
{
super::TickGame(seconds);
@@ -227,6 +227,7 @@ void LolImGui::TickGame(float seconds)
cursor.y = 1.f - cursor.y;
cursor *= video_size;
io.MousePos = ImVec2(cursor.x, cursor.y);
Log::Debug(Line("%.2f/%.2f"), io.MousePos.x, io.MousePos.y);
io.MouseWheel = m_controller->GetAxisValue(LolImGuiAxis::Scroll);

for (int i = LolImGuiKey::MOUSE_KEY_START; i < LolImGuiKey::MOUSE_KEY_END; ++i)
@@ -237,8 +238,13 @@ void LolImGui::TickGame(float seconds)
io.MouseDown[i - LolImGuiKey::MOUSE_KEY_START] = m_controller->IsKeyPressed(i);
break;
case LolImGuiKey::Focus:
if (m_controller->IsKeyPressed(i))
if (m_controller->IsKeyReleased(i))
{
Log::Debug(Line("Not focused ....."));
io.MousePos = ImVec2(-1.f, -1.f);
}
else
Log::Debug(Line("Focused !!"));
break;
}
}
@@ -247,18 +253,23 @@ void LolImGui::TickGame(float seconds)
// Start the frame
ImGui::NewFrame();
}

//-----------------------------------------------------------------------------
void LolImGui::TickDraw(float seconds, Scene &scene)
{
super::TickDraw(seconds, scene);

ImGuiIO& io = ImGui::GetIO();
scene.AddPrimitive(new PrimitiveLolImGui());
}
void PrimitiveLolImGui::Render() const
{
g_renderer->Clear(ClearMask::Depth);

ImGuiIO& io = ImGui::GetIO();
if (io.Fonts->TexID)
ImGui::Render();
}



//// Data
//static GLFWwindow* g_Window = NULL;
//static double g_Time = 0.0f;


+ 8
- 0
src/lolimgui.h View File

@@ -173,6 +173,14 @@ protected:
//map<ImGuiKey_, LolImGuiKey> m_keys;
};

//-----------------------------------------------------------------------------
class PrimitiveLolImGui : public Primitive
{
public:
PrimitiveLolImGui() { }
virtual void Render() const;
};

//bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks);
//void ImGui_ImplGlfw_Shutdown();
//void ImGui_ImplGlfw_NewFrame();


+ 40
- 9
src/lolua/baselua.h View File

@@ -271,13 +271,19 @@ public:
{
GetInc(l, index);
}
inline T* operator ()() { return m_value; }
inline T* operator ->() { return m_value; }
inline T* operator=(T* value) { m_value = value; }

inline T* operator ()() { return m_value; }
inline T* operator ->() { return m_value; }
inline T* operator=(T* value) { m_value = value; }
inline T* GetValue() { return m_value; }
inline bool IsValid(LuaState* l, int index)
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_optional;
}
private:
inline void GetInc(LuaState* l, int& index)
{
@@ -660,6 +666,10 @@ public:
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_value.IsOptional();
}
private:
void GetInc(LuaState* l, int& index)
{
@@ -768,7 +778,7 @@ public:
{
GetInc(l, index);
}
VarEnum(vec4 value, LuaState* l, int& index, bool optional = false)
VarEnum(SafeEnum<E> value, LuaState* l, int& index, bool optional = false)
: VarEnum(value, optional)
{
GetInc(l, index);
@@ -781,6 +791,10 @@ public:
{
return InnerIsValid(l, index);
}
inline bool IsOptional()
{
return m_optional;
}
private:
void GetInc(LuaState* l, int& index)
{
@@ -866,15 +880,22 @@ public:
template<typename T>
Stack& operator>>(T& var)
{
var = T(m_state, m_index);
var = T(var.GetValue(), m_state, m_index, var.IsOptional());
return *this;
}

/*
template<typename T>
Stack& operator>>(Var<T>& var)
{
var = Var<T>(m_state, m_index);
return *this;
var = Var<T>(var.GetValue(), m_state, m_index, var.IsOptional());
return *this;
}
template<typename T>
Stack& operator>>(Var<T>& var)
{
var = Var<T>(var.GetValue(), m_state, m_index, var.IsOptional());
return *this;
}
template<typename T>
Stack& operator>>(VarPtr<T>& var)
@@ -882,6 +903,15 @@ public:
var = VarPtr<T>(m_state, m_index);
return *this;
}
*/
/*
template<typename T>
Stack& operator>>(T& var)
{
Var<T> ret(m_state, m_index);
var = ret.GetValue();
return *this;
}
template<typename T>
Stack& operator>>(VarPtrLight<T>& var)
{
@@ -899,9 +929,10 @@ public:
}
/*
template<typename T>
Stack& operator<<(Var<T>& var)
Stack& operator<<(T& var)
{
m_result += var.Return(m_state);
Var<T> ret(var, false);
m_result += ret.Return(m_state);
return *this;
}
template<typename T>


+ 2
- 2
src/mesh/mesh.cpp View File

@@ -121,7 +121,7 @@ void SubMesh::Render()
attribs[j] = m_shader->GetAttribLocation(usage, usages[usage_index]++);
}

vertex_count = m_vbos[i]->GetSize() / m_vdecl->GetStream(i).GetSize();
vertex_count = (int)m_vbos[i]->GetSize() / m_vdecl->GetStream(i).GetSize();

m_vdecl->SetStream(m_vbos[i], attribs);
}
@@ -136,7 +136,7 @@ void SubMesh::Render()
m_ibo->Bind();
m_vdecl->Bind();
m_vdecl->DrawIndexedElements(MeshPrimitive::Triangles, 0, 0, vertex_count,
0, m_ibo->GetSize() / sizeof(uint16_t));
0, (int)m_ibo->GetSize() / sizeof(uint16_t));
m_vdecl->Unbind();
m_ibo->Unbind();
}


+ 8
- 2
src/mesh/mesh.h View File

@@ -49,6 +49,8 @@ namespace lol

class Mesh
{
friend class Scene;

public:
Mesh();
~Mesh();
@@ -56,9 +58,10 @@ public:
/* FIXME: this should eventually take a “material” as argument, which
* may behave differently between submeshes. */
void SetMaterial(Shader *shader);

protected:
void Render();

public:
array<class SubMesh *> m_submeshes;
};

@@ -72,6 +75,9 @@ public:

class SubMesh
{
friend class PrimitiveMesh;
friend class Mesh;

public:
SubMesh(Shader *shader, VertexDeclaration* vdecl);
~SubMesh();
@@ -84,9 +90,9 @@ public:
void SetIndexBuffer(IndexBuffer* ibo);
void AddTexture(const char* name, Texture* texture);

protected:
void Render();

protected:
MeshPrimitive m_mesh_prim;
Shader *m_shader;
VertexDeclaration* m_vdecl;


+ 60
- 2
src/mesh/primitive.cpp View File

@@ -20,15 +20,73 @@ namespace lol
* Primitive class
*/

Primitive::Primitive(SubMesh *submesh, mat4 const &matrix)
PrimitiveMesh::PrimitiveMesh(SubMesh *submesh, mat4 const &matrix)
: m_submesh(submesh),
m_matrix(matrix)
{
}

Primitive::~Primitive()
PrimitiveMesh::~PrimitiveMesh()
{
}

void PrimitiveMesh::Render() const
{
/* TODO: this should be the main entry for rendering of all
* primitives found in the scene graph. When we have one. */

Shader *shader = nullptr;
ShaderUniform u_model, u_modelview, u_normalmat, uni_tex, uni_texsize;
ShaderAttrib a_pos, a_tex;

{
/* If this primitive uses a new shader, update attributes */
if (m_submesh->GetShader() != shader)
{
shader = m_submesh->GetShader();

a_pos = shader->GetAttribLocation(VertexUsage::Position, 0);
a_tex = shader->GetAttribLocation(VertexUsage::TexCoord, 0);

shader->Bind();

/* Per-scene matrices */
ShaderUniform u_mat;
u_mat = shader->GetUniformLocation("u_projection");
shader->SetUniform(u_mat, g_scene->GetCamera()->GetProjection());
u_mat = shader->GetUniformLocation("u_view");
shader->SetUniform(u_mat, g_scene->GetCamera()->GetView());
u_mat = shader->GetUniformLocation("u_inv_view");
shader->SetUniform(u_mat, inverse(g_scene->GetCamera()->GetView()));

/* Per-object matrices, will be set later */
u_model = shader->GetUniformLocation("u_model");
u_modelview = shader->GetUniformLocation("u_modelview");
u_normalmat = shader->GetUniformLocation("u_normalmat");

/* Per-scene environment */
array<Light *> const &lights = g_scene->GetLights();
array<vec4> light_data;

/* FIXME: the 4th component of the position can be used for other things */
/* FIXME: GetUniform("blabla") is costly */
for (auto l : lights)
light_data << vec4(l->GetPosition(), (float)l->GetType()) << l->GetColor();
while (light_data.Count() < LOL_MAX_LIGHT_COUNT)
light_data << vec4::zero << vec4::zero;

ShaderUniform u_lights = shader->GetUniformLocation("u_lights");
shader->SetUniform(u_lights, light_data);
}

shader->SetUniform(u_model, m_matrix);
mat4 modelview = g_scene->GetCamera()->GetView() * m_matrix;
shader->SetUniform(u_modelview, modelview);
shader->SetUniform(u_normalmat, transpose(inverse(mat3(modelview))));

m_submesh->Render();
}
}

} /* namespace lol */


+ 4
- 5
src/mesh/primitive.h View File

@@ -15,18 +15,17 @@
// -------------------
//

#include "mesh/mesh.h"

namespace lol
{

class Primitive
class PrimitiveMesh : public Primitive
{
friend class Scene;

public:
Primitive(SubMesh *submesh, mat4 const &matrix);
~Primitive();
PrimitiveMesh(SubMesh *submesh, mat4 const &matrix);
virtual ~PrimitiveMesh();
virtual void Render() const;

private:
SubMesh *m_submesh;


+ 18
- 58
src/scene.cpp View File

@@ -56,7 +56,7 @@ class SceneData

private:
/* New scenegraph */
array<Primitive> m_primitives;
array<Primitive*> m_primitives;

/* Old API <P0, P1, COLOR, TIME, MASK> */
float m_new_line_time;
@@ -91,7 +91,7 @@ Scene::Scene(ivec2 size)
{
/* Create a default orthographic camera, in case the user doesn’t. */
data->m_default_cam = new Camera();
mat4 proj = mat4::ortho(0.f, size.x, 0.f, size.y, -1000.f, 1000.f);
mat4 proj = mat4::ortho(0.f, (float)size.x, 0.f, (float)size.y, -1000.f, 1000.f);
data->m_default_cam->SetProjection(proj);
PushCamera(data->m_default_cam);

@@ -133,7 +133,7 @@ int Scene::PushCamera(Camera *cam)

Ticker::Ref(cam);
data->m_camera_stack.Push(cam);
return data->m_camera_stack.Count() - 1;
return (int)data->m_camera_stack.Count() - 1;
}

void Scene::PopCamera(Camera *cam)
@@ -142,7 +142,7 @@ void Scene::PopCamera(Camera *cam)

/* Parse from the end because that’s probably where we’ll find
* our camera first. */
for (int i = data->m_camera_stack.Count(); i--; )
for (ptrdiff_t i = data->m_camera_stack.Count(); i--; )
{
if (data->m_camera_stack[i] == cam)
{
@@ -174,25 +174,33 @@ void Scene::Reset()
data->m_tile_bufs.Empty();

data->m_lights.Empty();

for (int i = 0; i < data->m_primitives.count(); i++)
delete data->m_primitives[i];
data->m_primitives.Empty();
}

/*TODO: SAM/TOUKY: Change that*/
void Scene::AddPrimitive(Mesh const &mesh, mat4 const &matrix)
{
for (int i = 0; i < mesh.m_submeshes.Count(); ++i)
{
data->m_primitives.Push(Primitive(mesh.m_submeshes[i],
matrix));
AddPrimitive(new PrimitiveMesh(mesh.m_submeshes[i], matrix));
}
}

void Scene::AddPrimitive(Primitive* primitive)
{
data->m_primitives.Push(primitive);
}

void Scene::AddTile(TileSet *tileset, int id, vec3 pos, int o, vec2 scale, float angle)
{
ASSERT(id < tileset->GetTileCount());

Tile t;
/* FIXME: this sorting only works for a 45-degree camera */
t.prio = -pos.y - (int)(2 * 32 * pos.z) + (o ? 0 : 32);
t.prio = (uint32_t)(-pos.y - (int)(2 * 32 * pos.z) + ((float)o ? 0 : 32));
t.tileset = tileset;
t.id = id;
t.pos = pos;
@@ -234,57 +242,9 @@ void Scene::RenderPrimitives()
/* TODO: this should be the main entry for rendering of all
* primitives found in the scene graph. When we have one. */

Shader *shader = nullptr;
ShaderUniform u_model, u_modelview, u_normalmat, uni_tex, uni_texsize;
ShaderAttrib a_pos, a_tex;

for (Primitive const &p : data->m_primitives)
for (Primitive* p : data->m_primitives)
{
/* If this primitive uses a new shader, update attributes */
if (p.m_submesh->GetShader() != shader)
{
shader = p.m_submesh->GetShader();

a_pos = shader->GetAttribLocation(VertexUsage::Position, 0);
a_tex = shader->GetAttribLocation(VertexUsage::TexCoord, 0);

shader->Bind();

/* Per-scene matrices */
ShaderUniform u_mat;
u_mat = shader->GetUniformLocation("u_projection");
shader->SetUniform(u_mat, GetCamera()->GetProjection());
u_mat = shader->GetUniformLocation("u_view");
shader->SetUniform(u_mat, GetCamera()->GetView());
u_mat = shader->GetUniformLocation("u_inv_view");
shader->SetUniform(u_mat, inverse(GetCamera()->GetView()));

/* Per-object matrices, will be set later */
u_model = shader->GetUniformLocation("u_model");
u_modelview = shader->GetUniformLocation("u_modelview");
u_normalmat = shader->GetUniformLocation("u_normalmat");

/* Per-scene environment */
array<Light *> const &lights = GetLights();
array<vec4> light_data;

/* FIXME: the 4th component of the position can be used for other things */
/* FIXME: GetUniform("blabla") is costly */
for (auto l : lights)
light_data << vec4(l->GetPosition(), l->GetType()) << l->GetColor();
while (light_data.Count() < LOL_MAX_LIGHT_COUNT)
light_data << vec4::zero << vec4::zero;

ShaderUniform u_lights = shader->GetUniformLocation("u_lights");
shader->SetUniform(u_lights, light_data);
}

shader->SetUniform(u_model, p.m_matrix);
mat4 modelview = GetCamera()->GetView() * p.m_matrix;
shader->SetUniform(u_modelview, modelview);
shader->SetUniform(u_normalmat, transpose(inverse(mat3(modelview))));

p.m_submesh->Render();
p->Render();
}
}

@@ -419,7 +379,7 @@ void Scene::RenderLines(float seconds) // XXX: rename to Blit()
rc.SetBlendEquation(BlendEquation::Add, BlendEquation::Max);
rc.SetAlphaFunc(AlphaFunc::GreaterOrEqual, 0.01f);

int linecount = data->m_lines.Count();
int linecount = (int)data->m_lines.Count();

if (!data->m_line_shader)
data->m_line_shader = Shader::Create(LOLFX_RESOURCE_NAME(line));


+ 15
- 1
src/scene.h View File

@@ -20,7 +20,6 @@
#include "tileset.h"
#include "light.h"
#include "camera.h"
#include "mesh/primitive.h"

#define LOL_MAX_LIGHT_COUNT 8

@@ -29,6 +28,20 @@ namespace lol

class SceneData;

//-----------------------------------------------------------------------------
class Primitive
{
friend class Scene;

public:
Primitive() { }
virtual ~Primitive() { }
virtual void Render() const { }

private:
};

//-----------------------------------------------------------------------------
class Scene
{
friend class Video;
@@ -51,6 +64,7 @@ public:

/* New scenegraph */
void AddPrimitive(Mesh const &mesh, mat4 const &matrix);
void AddPrimitive(Primitive* primitive);

/* FIXME: this should be deprecated -- it doesn't really match
* the architecture we want to build */


+ 1
- 1
src/sys/thread.cpp View File

@@ -174,7 +174,7 @@ int BaseThreadManager::GetDispatchedCount()
//-----------------------------------------------------------------------------
void BaseThreadManager::DispatchJob(ThreadJob* job)
{
m_job_dispatch << job;
if (job) m_job_dispatch << job;
}
void BaseThreadManager::DispatchJob(array<ThreadJob*> const& jobs)
{


+ 26
- 16
src/sys/threadtypes.cpp View File

@@ -52,19 +52,28 @@ public:
protected:
virtual bool DoWork()
{
array<String> pathlist = System::GetPathList(m_path);
File f;
f.Open(m_path, FileAccess::Read);
if (!f.IsValid())
return false;
if (!m_ready)
m_time = f.GetModificationTime();
else
for (String path : pathlist)
{
long int new_time = f.GetModificationTime();
if (new_time > m_time)
m_updated = true;
f.Open(path, FileAccess::Read);
if (f.IsValid())
{
long int new_time = f.GetModificationTime();
if (!m_ready)
{
m_time = new_time;
m_ready = true;
}
else if (new_time > m_time)
{
m_time = new_time;
m_updated = true;
}
return true;
}
}
return true;
return false;
}

//-----------------
@@ -114,6 +123,11 @@ void FileUpdateTester::UnregisterFile(FileUpdateTester::Status*& status)
//-----------------------------------------------------------------------------
void FileUpdateTester::TickGame(float seconds)
{
//Reset update for this frame
array<String> keys = m_files.keys();
for (String key : keys)
m_files[key]->SetUpdated(false);

super::TickGame(seconds);

if (!GetDispatchCount() && m_job_done.count())
@@ -122,10 +136,6 @@ void FileUpdateTester::TickGame(float seconds)
return;
m_frame_count = 0;

array<String> keys = m_files.keys();
for (String key : keys)
m_files[key]->SetUpdated(false);

DispatchJob(m_job_done);
m_job_done.empty();
}
@@ -139,9 +149,9 @@ void FileUpdateTester::TreatResult(ThreadJob* result)
{
m_files[job->GetPath()]->SetTime(job->GetTime());
m_files[job->GetPath()]->SetUpdated(true);
job->Restart();
m_job_done << job;
}
job->Restart();
m_job_done << job;
}

//AsyncImageJob ---------------------------------------------------------------


Loading…
Cancel
Save