// ----------------------------------------------------------------
// sets up the ogre viewports and associates the appropriate
// camera & render texture to each
// ----------------------------------------------------------------
bool OgreOpenVR::initOgreViewports()
{
Ogre::RenderTexture* renderTex = m_ogreRenderTexture->getBuffer()->getRenderTarget();
// configure the two viewports to each render to half of the render targer
// each half corresponds to one eye, and we submit both in one big texture to OpenVR
m_viewports[0] = renderTex->addViewport(m_cameras[0], 0, 0.0f, 0.0f, 0.5f, 1.0f);
m_viewports[1] = renderTex->addViewport(m_cameras[1], 1, 0.5f, 0.0f, 0.5f, 1.0f);
renderTex->setAutoUpdated(true);
m_viewports[0]->setBackgroundColour(Ogre::ColourValue(97 / 255.0f, 200 / 255.0f, 200 / 255.0f));
m_viewports[0]->setOverlaysEnabled(true);
m_viewports[0]->setAutoUpdated(true);
m_viewports[1]->setBackgroundColour(Ogre::ColourValue(97 / 255.0f, 200 / 255.0f, 200 / 255.0f));
m_viewports[1]->setOverlaysEnabled(true);
m_viewports[1]->setAutoUpdated(true);
Ogre::LogManager::getSingleton().logMessage(Ogre::LML_NORMAL, "OgreOpenVR: Setup RTT viewports for ogre OpenVR textures");
return true;
}
CRosRttTexture::CRosRttTexture(unsigned width, unsigned height, Ogre::Camera * camera, bool isDepth /*= false*/ )
: m_materialName("MyRttMaterial")
, width_(width)
, height_(height)
, frame_("/map")
, m_bIsDepth( isDepth )
{
assert( height > 0 && width > 0 );
{
// Set encoding
current_image_.encoding = ROS_IMAGE_FORMAT;
// Set image size
current_image_.width = width;
current_image_.height = height;
// Set image row length in bytes (row length * 3 bytes for a color)
current_image_.step = width * BPP;
#if OGRE_ENDIAN == ENDIAN_BIG
current_image_.is_bigendian = true;
#else
current_image_.is_bigendian = false;
#endif
// Resize data
current_image_.data.resize( width_ * height_ * BPP);
}
Ogre::TextureManager & lTextureManager( Ogre::TextureManager::getSingleton() );
Ogre::String textureName("RVIZ_CamCast_Texture");
bool lGammaCorrection( false );
unsigned int lAntiAliasing( 0 );
unsigned int lNumMipmaps( 0 );
if( isDepth )
{
texture_ = lTextureManager.createManual(textureName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D, width, height, lNumMipmaps,
OGRE_DEPTH_TEXTURE_FORMAT, Ogre::TU_RENDERTARGET, 0, lGammaCorrection, lAntiAliasing);
}
else
{
texture_ = lTextureManager.createManual(textureName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D, width, height, lNumMipmaps,
OGRE_TEXTURE_FORMAT, Ogre::TU_RENDERTARGET, 0, lGammaCorrection, lAntiAliasing);
}
// Create render target
Ogre::RenderTexture* lRenderTarget = NULL;
Ogre::HardwarePixelBufferSharedPtr lRttBuffer = texture_->getBuffer();
lRenderTarget = lRttBuffer->getRenderTarget();
lRenderTarget->setAutoUpdated(true);
// Create and attach viewport
Ogre::Viewport* lRttViewport1 = lRenderTarget->addViewport(camera, 50, 0.00f, 0.00f, 1.0f, 1.0f);
lRttViewport1->setAutoUpdated(true);
Ogre::ColourValue lBgColor1(0.0,0.0,0.0,1.0);
lRttViewport1->setBackgroundColour(lBgColor1);
// create a material using this texture.
//Get a reference on the material manager, which is a singleton.
Ogre::MaterialManager& lMaterialManager = Ogre::MaterialManager::getSingleton();
Ogre::MaterialPtr lMaterial = lMaterialManager.create(m_materialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::Technique * lTechnique = lMaterial->getTechnique(0);
Ogre::Pass* lPass = lTechnique->getPass(0);
if( isDepth )
{
lPass->setLightingEnabled(false);
}
Ogre::TextureUnitState* lTextureUnit = lPass->createTextureUnitState();
lTextureUnit->setTextureName(textureName);
lTextureUnit->setNumMipmaps(0);
lTextureUnit->setTextureFiltering(Ogre::TFO_BILINEAR);
update();
}
void RenderedTexture::renderTextures()
{
//Set up RTT texture
Ogre::TexturePtr renderTexture;
if (renderTexture.isNull()) {
renderTexture = Ogre::TextureManager::getSingleton().createManual(
getUniqueID("RenderedEntityMaterial"), "EntityRenderer",
Ogre::TEX_TYPE_2D, textureSize, textureSize, 0,
Ogre::PF_A8R8G8B8, Ogre::TU_RENDERTARGET, 0);
}
renderTexture->setNumMipmaps(0);
//Set up render target
Ogre::RenderTexture* renderTarget = renderTexture->getBuffer()->getRenderTarget();
renderTarget->setAutoUpdated(false);
//Set up camera
Ogre::SceneNode* camNode = sceneMgr->getSceneNode("EntityRenderer::cameraNode");
Ogre::Camera* renderCamera = sceneMgr->createCamera(getUniqueID("EntityRendererCam"));
camNode->attachObject(renderCamera);
renderCamera->setLodBias(1000.0f);
Ogre::Viewport* renderViewport = renderTarget->addViewport(renderCamera);
renderViewport->setOverlaysEnabled(false);
renderViewport->setClearEveryFrame(true);
renderViewport->setShadowsEnabled(false);
renderViewport->setBackgroundColour(Ogre::ColourValue(0.0f, 0.0f, 0.0f, 0.0f));
//Set up scene node
Ogre::SceneNode* node = sceneMgr->getSceneNode("EntityRenderer::renderNode");
Ogre::SceneNode* oldSceneNode = entity->getParentSceneNode();
if (oldSceneNode)
oldSceneNode->detachObject(entity);
node->attachObject(entity);
node->setPosition(-entityCenter);
//Set up camera FOV
const Ogre::Real objDist = entityRadius * 100;
const Ogre::Real nearDist = objDist - (entityRadius + 1);
const Ogre::Real farDist = objDist + (entityRadius + 1);
renderCamera->setAspectRatio(1.0f);
renderCamera->setFOVy(Ogre::Math::ATan(2.0 * entityRadius / objDist));
renderCamera->setNearClipDistance(nearDist);
renderCamera->setFarClipDistance(farDist);
//Disable mipmapping (without this, masked textures look bad)
Ogre::MaterialManager* mm = Ogre::MaterialManager::getSingletonPtr();
Ogre::FilterOptions oldMinFilter = mm->getDefaultTextureFiltering(Ogre::FT_MIN);
Ogre::FilterOptions oldMagFilter = mm->getDefaultTextureFiltering(Ogre::FT_MAG);
Ogre::FilterOptions oldMipFilter = mm->getDefaultTextureFiltering(Ogre::FT_MIP);
mm->setDefaultTextureFiltering(Ogre::FO_POINT, Ogre::FO_LINEAR,Ogre:: FO_NONE);
//Disable fog
Ogre::FogMode oldFogMode = sceneMgr->getFogMode();
Ogre::ColourValue oldFogColor = sceneMgr->getFogColour();
Ogre::Real oldFogDensity = sceneMgr->getFogDensity();
Ogre::Real oldFogStart = sceneMgr->getFogStart();
Ogre::Real oldFogEnd = sceneMgr->getFogEnd();
sceneMgr->setFog(Ogre::FOG_NONE);
// Get current status of the queue mode
Ogre::SceneManager::SpecialCaseRenderQueueMode OldSpecialCaseRenderQueueMode =
sceneMgr->getSpecialCaseRenderQueueMode();
//Only render the entity
sceneMgr->setSpecialCaseRenderQueueMode(Ogre::SceneManager::SCRQM_INCLUDE);
sceneMgr->addSpecialCaseRenderQueue(renderQueueGroup);
Ogre::uint8 oldRenderQueueGroup = entity->getRenderQueueGroup();
entity->setRenderQueueGroup(renderQueueGroup);
bool oldVisible = entity->getVisible();
entity->setVisible(true);
float oldMaxDistance = entity->getRenderingDistance();
entity->setRenderingDistance(0);
//Calculate the filename hash used to uniquely identity this render
std::string strKey = entityKey;
char key[32] = {0};
Ogre::uint32 i = 0;
for (std::string::const_iterator it = entityKey.begin(); it != entityKey.end(); ++it) {
key[i] ^= *it;
i = (i+1) % sizeof(key);
}
for (i = 0; i < sizeof(key); ++i)
key[i] = (key[i] % 26) + 'A';
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
GetUserDir().string(), "FileSystem", "BinFolder");
std::string fileNamePNG =
"Rendered." + std::string(key, sizeof(key)) + '.' +
Ogre::StringConverter::toString(textureSize) + ".png";
//Attempt to load the pre-render file if allowed
bool needsRegen = false;
if (!needsRegen) {
try{
texture = Ogre::TextureManager::getSingleton().load(
fileNamePNG, "BinFolder", Ogre::TEX_TYPE_2D, 0);
} catch (...) {
needsRegen = true;
}
}
if (needsRegen) {
//If this has not been pre-rendered, do so now
//Position camera
camNode->setPosition(0, 0, 0);
// TODO camNode->setOrientation(Quaternion(yaw, Vector3::UNIT_Y) * Quaternion(-pitch, Vector3::UNIT_X));
camNode->translate(Ogre::Vector3(0, 0, objDist), Ogre::Node::TS_LOCAL);
renderTarget->update();
//Save RTT to file
renderTarget->writeContentsToFile((GetUserDir() / fileNamePNG).string());
//Load the render into the appropriate texture view
texture = Ogre::TextureManager::getSingleton().load(fileNamePNG, "BinFolder", Ogre::TEX_TYPE_2D, 0);
ggTexture = ClientUI::GetTexture(GetUserDir() / fileNamePNG);
}
entity->setVisible(oldVisible);
entity->setRenderQueueGroup(oldRenderQueueGroup);
entity->setRenderingDistance(oldMaxDistance);
sceneMgr->removeSpecialCaseRenderQueue(renderQueueGroup);
// Restore original state
sceneMgr->setSpecialCaseRenderQueueMode(OldSpecialCaseRenderQueueMode);
//Re-enable mipmapping
mm->setDefaultTextureFiltering(oldMinFilter, oldMagFilter, oldMipFilter);
//Re-enable fog
sceneMgr->setFog(oldFogMode, oldFogColor, oldFogDensity, oldFogStart, oldFogEnd);
//Delete camera
renderTarget->removeViewport(0);
renderCamera->getSceneManager()->destroyCamera(renderCamera);
//Delete scene node
node->detachAllObjects();
if (oldSceneNode)
oldSceneNode->attachObject(entity);
//Delete RTT texture
assert(!renderTexture.isNull());
std::string texName2(renderTexture->getName());
renderTexture.setNull();
if (Ogre::TextureManager::getSingletonPtr())
Ogre::TextureManager::getSingleton().remove(texName2);
}
CFakeObjectEntityManager::FakeObjectMap::iterator CFakeObjectEntityManager::_GetFakeNode(LPCTSTR szNodeName, tEntityNode* pNode, LPCTSTR szCameraName, int nTexWidth, int nTexHeight, LPCTSTR szBackgroundName)
{
//缺省摄像机的位置
static const float s_fHeight = 0.8f;
static const float s_fDistance = 3.2f;
static const float s_fPitch = 0.21f;
FakeObjectMap::iterator it = m_mapObject.find(szNodeName);
if(it != m_mapObject.end()) return it;
//不存在，创建
FakeObject newNode;
newNode.strName = szNodeName;
//--------------------------------------------------
//创建RenderTarget
Ogre::TexturePtr ptrTex =
Ogre::TextureManager::getSingleton().createManual(
Ogre::String(szNodeName) + "_RenderTexture",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,
nTexWidth, nTexHeight, 1, 0,
Ogre::PF_R8G8B8A8,
Ogre::TU_RENDERTARGET,
0);
//ptrTex->load();
newNode.ptrRenderTexture = ptrTex;
Ogre::RenderTexture* pTexture = ptrTex->getBuffer()->getRenderTarget();
//缺省不刷新
pTexture->setAutoUpdated(false);
pTexture->addListener(&g_theListener);
//--------------------------------------------------
//放置摄像机
Ogre::SceneManager* pScnManager = CEngineInterface::GetMe()->GetFairySystem()->getSceneManager();
newNode.pCamera = pScnManager->createCamera(Ogre::String(szNodeName) + "_Camera");
//放缩系数
fVector3 fvScale = CEngineInterface::GetMe()->GetSacle();
newNode.fCameraHeight=s_fHeight;
newNode.fCameraDistance=s_fDistance;
newNode.fCameraPitch=s_fPitch;
STRING szUserCameraValue;
pNode->Actor_GetObjectProperty(szCameraName, szUserCameraValue);
// if(szUserCameraValue.size() > 2 && szUserCameraValue.find(';') != STRING::npos)
// {
// sscanf(szUserCameraValue.c_str(), "%f;%f", &(newNode.fCameraHeight), &(newNode.fCameraDistance));
// }
int Row_Index;
Row_Index = atoi(szUserCameraValue.c_str());
const tDataBase* pDBC = g_pDataBase->GetDataBase(DBC_MODEL_PARAMETER);
KLAssert(pDBC);
const _DBC_MODEL_PARAMETER* pParameter = NULL;
pParameter = (const _DBC_MODEL_PARAMETER*)((tDataBase*)pDBC)->Search_Index_EQU(Row_Index);
if(pParameter)
{
newNode.fCameraHeight = pParameter->nHeight;
newNode.fCameraDistance = pParameter->nDistance;
}
//设置摄像机
_UpdateCamera(newNode);
newNode.pCamera->setNearClipDistance(10.f);
newNode.pCamera->setAspectRatio((float)nTexWidth/nTexHeight);
newNode.pCamera->setFOVy(Ogre::Degree(45.0f)); // 经验值
newNode.pCamera->setProjectionType(Ogre::PT_PERSPECTIVE); //透视投影 (平行投影 Ogre::PT_ORTHOGRAPHIC)
//--------------------------------------------------
//创建ViewPort
newNode.pViewPort = pTexture->addViewport(newNode.pCamera, 1);
newNode.pViewPort->setClearEveryFrame(true);
newNode.pViewPort->setBackgroundColour(Ogre::ColourValue(0,0,0,0));
newNode.pViewPort->setOverlaysEnabled(false);
newNode.pViewPort->setSkiesEnabled(false);
newNode.pViewPort->setShadowsEnabled(false);
//--------------------------------------------------
//创建rectangle(如果纹理名称不为空并且所需的material template存在)
Ogre::String backgroundTexName(szBackgroundName);
Ogre::MaterialPtr originMat = Ogre::MaterialManager::getSingleton().getByName("UIModelBackground");
if (false == backgroundTexName.empty() && false == originMat.isNull())
{
newNode.pRectange = new Ogre::Rectangle2D(true);
newNode.pRectange->setCorners(-1.0f, 1.0f, 1.0f, -1.0f);
Ogre::String cloneMatName = Ogre::String(szNodeName) + "_Rectangle";
Ogre::MaterialPtr cloneMat = Ogre::MaterialManager::getSingleton().getByName(cloneMatName);
if (cloneMat.isNull())
{
cloneMat = originMat->clone(cloneMatName);
if (cloneMat->getNumTechniques())
{
Ogre::Technique* tech = cloneMat->getTechnique(0);
if (tech->getNumPasses())
{
Ogre::Pass* pass = tech->getPass(0);
if (pass->getNumTextureUnitStates())
{
Ogre::TextureUnitState* tex = pass->getTextureUnitState(0);
tex->setTextureName(szBackgroundName);
}
}
}
}
newNode.pRectange->setMaterial(cloneMat->getName());
newNode.pRectange->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND);
newNode.pRectange->setVisibilityFlags(Fairy::OVF_GUI_ELEMENTS);
// 设置boundingbox为无限大，以防被camera剔除掉（默认的包围盒大小为-1，1）
newNode.pRectange->setBoundingBox(
Ogre::AxisAlignedBox(
Ogre::Vector3(Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY, Ogre::Math::NEG_INFINITY),
Ogre::Vector3(Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY, Ogre::Math::POS_INFINITY)
) );
Ogre::SceneNode* parentNode =
CEngineInterface::GetMe()->GetFairySystem()->getBaseSceneNode()->createChildSceneNode();
parentNode->attachObject(newNode.pRectange);
}
//--------------------------------------------------
//加入Map
m_mapObject.insert(std::make_pair(newNode.strName, newNode));
it = m_mapObject.find(newNode.strName);
KLAssert(it != m_mapObject.end());
//加入索引Map
m_mapIndexOfViewPort.insert(std::make_pair(newNode.pViewPort, &(it->second)));
return it;
}