i've just tried to get the imgui library to work in a simple way like my other ingame gui.
So far i can render the vertices. But the problem is the projection matrix i think ..
I do not realy understand that stuff so maybe someone could enlighten me?
I think i need to set the projmatrix like chaoscreator:
Code: Select all
Ogre::Matrix4 projMatrix(2.0f / io.DisplaySize.x, 0.0f, 0.0f, -1.0f,
0.0f, -2.0f / io.DisplaySize.y, 0.0f, 1.0f,
0.0f, 0.0f, -1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
mPass->getVertexProgramParameters()->setNamedConstant("ProjectionMatrix", projMatrix);
I'm using a movableobject/renderable. If i remove the 2d stuff:
i get the 3d presentation, but flipped.// use identity projection and view matrices
// mUseIdentityProjection = true;
// mUseIdentityView = true;
In 2d mode nothing is displayed.
My MovableObject code:
Code: Select all
#include <XERenderer/Editor/ImgGuiRenderable.hpp>
#include <XERenderer/GUI/GUIRenderer.hpp>
#include <XERenderer/GraphicsManager.hpp>
#include <Ogre/OgreMain/include/OgreSceneManager.h>
#include <Ogre/OgreMain/include/OgreRoot.h>
#include "OgreHlmsManager.h"
#include "OgreHlms.h"
#include <ThirdParty/imgui/imgui.h>
#include <OgreHardwarePixelBuffer.h>
#include <Ogre/OgreMain/include/OgreMaterial.h>
#include <Ogre/OgreMain/include/OgreTechnique.h>
namespace XE {
ImgGuiRenderable::ImgGuiRenderable(Uint32 id, GUIRenderer& guiRenderer,
Ogre::ObjectMemoryManager* objManager, Ogre::SceneManager* sceneMgr)
: MovableObject(id, objManager, sceneMgr, 0)
, Renderable()
, m_guiRenderer(guiRenderer)
, m_sceneMgr(sceneMgr)
, m_sceneNodeLines(0)
, mOperationType(Ogre::OperationType::OT_TRIANGLE_LIST)
, _initalizied(false)
{
createFontTexture();
//set renderqueue -> opengl error bind buffer after adding item??
sceneMgr->getRenderQueue()->setRenderQueueMode(7, Ogre::RenderQueue::Modes::FAST);
this->setRenderQueueGroup(7);
m_sceneNodeLines = sceneMgr->getRootSceneNode(Ogre::SCENE_DYNAMIC)->createChildSceneNode(Ogre::SCENE_DYNAMIC);
m_sceneNodeLines->attachObject(this);
Ogre::RenderSystem *renderSystem = m_guiRenderer.getGraphicsManager().getRoot()->getRenderSystem();
m_VaoManager = renderSystem->getVaoManager();
Ogre::Aabb aabb(Ogre::Aabb::BOX_INFINITE);
mObjectData.mLocalAabb->setFromAabb(aabb, mObjectData.mIndex);
mObjectData.mWorldAabb->setFromAabb(aabb, mObjectData.mIndex);
mObjectData.mLocalRadius[mObjectData.mIndex] = std::numeric_limits<Ogre::Real>::max();
mObjectData.mWorldRadius[mObjectData.mIndex] = std::numeric_limits<Ogre::Real>::max();
// default overlays to preserve their own detail level
mPolygonModeOverrideable = false;
//>>>>>-------------- 2D --------------------
// use identity projection and view matrices
// mUseIdentityProjection = true;
// mUseIdentityView = true;
//<<<<<-------------- 2D --------------------
}
void ImgGuiRenderable::getRenderOperation(Ogre::v1::RenderOperation& op, bool casterPass) {
OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED,
"ImgGuiRenderable does not implement getRenderOperation. "
"Use MovableObject::setRenderQueueGroup to change the group.",
"ImgGuiRenderable::getRenderOperation");
}
void ImgGuiRenderable::updateVertices(float delta)
{
//return;
ImGuiIO& io = ImGui::GetIO();
io.DeltaTime = delta;
// Setup display size (every frame to accommodate for window resizing)
io.DisplaySize = ImVec2(800, 600);
ImGui::NewFrame();
bool show_test_window = true;
ImGui::ShowTestWindow(&show_test_window);
//Tell ImGui to create the buffers
ImGui::Render();
ImDrawData *draw_data = ImGui::GetDrawData();
if (!draw_data)
return;
clear();
Ogre::VertexElement2Vec vertexElements;
vertexElements.push_back(Ogre::VertexElement2(Ogre::VET_FLOAT2, Ogre::VES_POSITION));
vertexElements.push_back(Ogre::VertexElement2(Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES));
vertexElements.push_back(Ogre::VertexElement2(Ogre::VET_COLOUR, Ogre::VES_DIFFUSE));
size_t maxVertices = 50000;
size_t maxIndices = 50000;
m_vertexBuffer = m_VaoManager->createVertexBuffer(vertexElements, maxVertices, Ogre::BT_DYNAMIC_PERSISTENT_COHERENT, 0, false);
m_indexBuffer = m_VaoManager->createIndexBuffer(Ogre::IndexBufferPacked::IT_16BIT, maxIndices, Ogre::BT_DYNAMIC_DEFAULT, NULL, false);
//Now the Vao
Ogre::VertexBufferPackedVec vertexBuffers;
vertexBuffers.push_back(m_vertexBuffer);
m_Vao = m_VaoManager->createVertexArrayObject(vertexBuffers, m_indexBuffer, Ogre::OperationType::OT_TRIANGLE_LIST);
mVaoPerLod[0].push_back(m_Vao);
if (!_initalizied)
{
setDatablock("HlmsUnlitImgui"); // set this after createVertexArrayObject and mVaoPerLod[0].push_back(vao) ?? or else crash in renderable
setCastShadows(false);
mRenderables.push_back(this);
_initalizied = true;
}
ImDrawVert* vtx_dst = (ImDrawVert*)(m_vertexBuffer->map(0, maxVertices));
ImDrawIdx* idx_dst = (ImDrawIdx*)m_indexBuffer->map(0, maxIndices);
//iterate through all lists (at the moment every window has its own)
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.size() * sizeof(ImDrawVert));
memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.size() * sizeof(ImDrawIdx));
vtx_dst += cmd_list->VtxBuffer.size();
idx_dst += cmd_list->IdxBuffer.size();
}
m_vertexBuffer->unmap(Ogre::UO_UNMAP_ALL);
m_indexBuffer->unmap(Ogre::UO_UNMAP_ALL);
Ogre::Aabb aabb2(Ogre::Aabb::BOX_INFINITE);//2D
mObjectData.mLocalAabb->setFromAabb(aabb2, mObjectData.mIndex); //2D
mObjectData.mWorldAabb->setFromAabb(aabb2, mObjectData.mIndex); //2D
//mObjectData.mLocalAabb->setFromAabb(aabb, mObjectData.mIndex); //3D
//mObjectData.mLocalRadius[mObjectData.mIndex] = aabb.getRadius();//3D
mObjectData.mLocalRadius[mObjectData.mIndex] = std::numeric_limits<Ogre::Real>::max();
mObjectData.mWorldRadius[mObjectData.mIndex] = std::numeric_limits<Ogre::Real>::max();
}
void ImgGuiRenderable::clear()
{
if (!_initalizied)
return;
//clear aabb
mObjectData.mLocalAabb->setFromAabb(Ogre::Aabb::BOX_NULL, mObjectData.mIndex);
mObjectData.mLocalRadius[mObjectData.mIndex] = 0.0f;
Ogre::VertexArrayObject *vao = m_Vao;
if (vao)
{
Ogre::VaoManager *vaoManager = m_VaoManager;
const Ogre::VertexBufferPackedVec &vertexBuffers = vao->getVertexBuffers();
Ogre::VertexBufferPackedVec::const_iterator itBuffers = vertexBuffers.begin();
Ogre::VertexBufferPackedVec::const_iterator endBuffers = vertexBuffers.end();
while (itBuffers != endBuffers)
{
Ogre::VertexBufferPacked * vertexBuffer = *itBuffers;
if (vertexBuffer->getMappingState() != Ogre::MS_UNMAPPED)
{
vertexBuffer->unmap(Ogre::UO_UNMAP_ALL);
}
vaoManager->destroyVertexBuffer(vertexBuffer);
++itBuffers;
}
Ogre::IndexBufferPacked * indexBuffer = vao->getIndexBuffer();
if (indexBuffer)
{
if (indexBuffer->getMappingState() != Ogre::MS_UNMAPPED)
{
indexBuffer->unmap(Ogre::UO_UNMAP_ALL);
}
vaoManager->destroyIndexBuffer(indexBuffer);
}
vaoManager->destroyVertexArrayObject(vao);
}
m_Vao = 0;
mVaoPerLod[0].clear();
mVaoPerLod[1].clear();
}
ImgGuiRenderable::~ImgGuiRenderable()
{
//m_sceneMgr->destroyManualObject(this);
m_sceneMgr->destroySceneNode(m_sceneNodeLines);
}
const Ogre::String& ImgGuiRenderable::getMovableType(void) const
{
return "ImgGUI";
}
void ImgGuiRenderable::createFontTexture()
{
// Build texture atlas
ImGuiIO& io = ImGui::GetIO();
unsigned char* pixels;
int width, height;
io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
mFontTex = Ogre::TextureManager::getSingleton().createManual("ImguiFontTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, width, height, 1, 1, Ogre::PF_R8G8B8A8);
const Ogre::PixelBox & lockBox = mFontTex->getBuffer()->lock(Ogre::Image::Box(0, 0, width, height), Ogre::v1::HardwareBuffer::HBL_DISCARD);
size_t texDepth = Ogre::PixelUtil::getNumElemBytes(lockBox.format);
memcpy(lockBox.data, pixels, width*height*texDepth);
mFontTex->getBuffer()->unlock();
}
}
Code: Select all
#pragma once
#include <XESystem/SystemConfig.hpp>
//#include <Ogre/OgreMain/include/OgreManualObject2.h>
#include <Ogre/OgreMain/include/OgreMovableObject.h>
#include <Ogre/OgreMain/include/OgreRenderable.h>
#include <OgreTexture.h>
//Ogre::v1
#include <Ogre/OgreMain/include/OgreRenderOperation.h>
#include <vector>
#include <memory>
namespace Ogre {
class VertexBufferPacked;
class ObjectMemoryManager;
class SceneManager;
typedef std::string String;
}
namespace XE {
struct Vertex;
class CameraRenderable;
class GUIRenderer;
class RenderableShape;
class ImgGuiRenderable : public Ogre::MovableObject, public Ogre::Renderable
{
public:
ImgGuiRenderable(Uint32 id, GUIRenderer& guiRenderer,
Ogre::ObjectMemoryManager* objManager, Ogre::SceneManager* sceneMgr);
~ImgGuiRenderable();
// MovableObject overrides
/** @copydoc MovableObject::getMovableType. */
const Ogre::String& getMovableType(void) const;
void updateVertices(float delta);
// Renderable overrides
/** @copydoc Renderable::getRenderOperation. */
virtual void getRenderOperation(Ogre::v1::RenderOperation& op, bool casterPass) OGRE_OVERRIDE;
/** @copydoc Renderable::getWorldTransforms. */
virtual void getWorldTransforms(Ogre::Matrix4* xform) const OGRE_OVERRIDE {}
/** @copydoc Renderable::getLights. */
virtual const Ogre::LightList &getLights(void) const OGRE_OVERRIDE { return queryLights(); }
/** @copydoc Renderable::getCastsShadows. */
virtual bool getCastsShadows(void) const { return false; }
protected:
//called from Ogre::Renderable
Ogre::OperationType mOperationType;
private:
void createFontTexture();
void clear();
bool _initalizied;
Ogre::SceneManager* _t_OgreSceneMgrPtr;
Ogre::ObjectMemoryManager* _t_objectMemoryManager;
Ogre::VertexArrayObject * m_Vao;
Ogre::VaoManager * m_VaoManager;
Ogre::VertexElement2Vec m_VertexElements;
Ogre::VertexBufferPacked *m_vertexBuffer;
Ogre::IndexBufferPacked* m_indexBuffer;
GUIRenderer& m_guiRenderer;
Ogre::SceneManager* m_sceneMgr;
Ogre::SceneNode* m_sceneNodeLines;
Ogre::TexturePtr mFontTex;
};
}
Code: Select all
hlms HlmsUnlitImgui unlit
{
diffuse_map ImguiFontTex
scene_blend alpha_blend
depth_check off
depth_write off
cull_mode none
}