void GridLineFactory::createMaterials(void)
{
Ogre::MaterialPtr myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("RedGridLine","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(1,0,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(1,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1,0,0);
//myManualObjectMaterial->dispose(); // dispose pointer, not the material
myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("GreenGridLine","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,1,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(0,1,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,1,0);
myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("BlueGridLine","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,0,1,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(0,0,1);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,0,1);
//materialsCreated = true;
}
/**-------------------------------------------------------------------------------
SensorDecoratorVector
@brief
@param color
@return
---------------------------------------------------------------------------------*/
SensorDecoratorVector::SensorDecoratorVector(Sensor* sensor, const Ogre::ColourValue& color, bool persistent)
: SensorDecorator(sensor), ManualObject(sensor->getSensorName())
{
Ogre::SceneNode* myManualObjectNode = getSimulation()->getScene()->getSceneManager().getRootSceneNode()->createChildSceneNode(mName + "_node");
Ogre::MaterialPtr myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create(mName + "Material", OGRE_DEBUG_GROUP);
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(color);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(color);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(color);
myManualObjectNode->attachObject(this);
mPersistent = persistent;
mVisible = false;
Ogre::Vector3 zero(0,0,0);
begin(mName + "Material", Ogre::RenderOperation::OT_LINE_LIST);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
position(zero);
end();
}
void EC_SkyBox::CreateSky()
{
if (!ViewEnabled())
return;
if (renderer_.expired())
return;
QString currentMaterial = materialRef.Get().ref;
Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(currentMaterial.toStdString().c_str());
if (materialPtr.isNull())
{
LogError("Could not get SkyBox material : " + currentMaterial.toStdString());
return;
}
materialPtr->setReceiveShadows(false);
try
{
//RexTypes::Vector3 v = angleAxisAttr.Get();
//Ogre::Quaternion rotation(Ogre::Degree(90.0), Ogre::Vector3(1, 0, 0));
Quaternion o = orientation.Get();
renderer_.lock()->GetSceneManager()->setSkyBox(true, currentMaterial.toStdString().c_str(), distance.Get(),
drawFirst.Get(), Ogre::Quaternion(o.w, o.x, o.y, o.z));
}
catch(Ogre::Exception& e)
{
LogError("Could not set SkyBox: " + std::string(e.what()));
}
}
PDebugger::PDebugger(Ogre::SceneManager *mgr, PLevel *lv, PPlayer *pl) :
mNode(NULL), mLevel(lv), mPlayer(pl)
{
mMObject = new Ogre::ManualObject("PLevelDebug");
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("matDebug","Grup_prova");
mat->setReceiveShadows(false);
mat->getTechnique(0)->setLightingEnabled(true);
mat->getTechnique(0)->getPass(0)->setDiffuse(0,1,0,0);
mat->getTechnique(0)->getPass(0)->setAmbient(0,1,0);
mat->getTechnique(0)->getPass(0)->setSelfIllumination(0,1,0);
mMObject->begin("matDebug", Ogre::RenderOperation::OT_LINE_LIST);
//comencem indexacio
cpShape *shape;
cpSegmentShape *s;
cpVect v;
const Ogre::Real zeta = -7.0f;
for(int i=0;; i++)
{
shape = mLevel->getSegment(i);
if(shape==NULL) break; //ja hem acabat
v = cpSegmentShapeGetA(shape);
mMObject->position(v.x, v.y, zeta);
std::cerr << v.x << " " << v.y << std::endl;
v = cpSegmentShapeGetB(shape);
mMObject->position(v.x, v.y, zeta);
std::cerr << v.x << " " << v.y << std::endl;
}
mMObject->end();
mNode = mgr->getRootSceneNode()->createChildSceneNode("PLevelDebugNode");
mNode->attachObject(mMObject);
}
void EC_Sky::CreateSky()
{
if (!ViewEnabled())
return;
if (world_.expired())
return;
QString currentMaterial = materialRef.Get().ref;
Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(currentMaterial.toStdString().c_str());
//Ogre::MaterialPtr materialPtr = Ogre::MaterialManager::getSingleton().getByName(framework->Asset()->LookupAssetRefToStorage(materialRef.Get().ref).toStdString().c_str());
if (materialPtr.isNull())
{
LogError("Could not get SkyBox material : " + currentMaterial.toStdString());
return;
}
materialPtr->setReceiveShadows(false);
try
{
world_.lock()->GetSceneManager()->setSkyBox(true, currentMaterial.toStdString().c_str(), distance.Get(),
drawFirst.Get(), orientation.Get());
}
catch(Ogre::Exception& e)
{
LogError("Could not set SkyBox: " + std::string(e.what()));
}
}
void _drawGridPlane(void)
{
Ogre::ManualObject* gridPlane = mSceneMgr->createManualObject("GridPlane");
Ogre::SceneNode* gridPlaneNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("GridPlaneNode");
Ogre::MaterialPtr gridPlaneMaterial = Ogre::MaterialManager::getSingleton().create("GridPlanMaterial", "General");
gridPlaneMaterial->setReceiveShadows(false);
gridPlaneMaterial->getTechnique(0)->setLightingEnabled(true);
gridPlaneMaterial->getTechnique(0)->getPass(0)->setDiffuse(1, 1, 1, 0);
gridPlaneMaterial->getTechnique(0)->getPass(0)->setAmbient(1, 1, 1);
gridPlaneMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1, 1, 1);
gridPlane->begin("GridPlaneMaterial", Ogre::RenderOperation::OT_LINE_LIST);
for (int i = 0; i < 21; i++)
{
gridPlane->position(-500.0f, 0.0f, 500.0f - i * 50);
gridPlane->position(500.0f, 0.0f, 500.0f - i * 50);
gridPlane->position(-500.f + i * 50, 0.f, 500.0f);
gridPlane->position(-500.f + i * 50, 0.f, -500.f);
}
gridPlane->end();
gridPlaneNode->attachObject(gridPlane);
}
void OgreBtDebugDrawer::initialize(Ogre::SceneManager* const sceneManager,
const bool drawTrajectory) {
mDrawTrajectory = drawTrajectory;
mContactPoints = &mContactPoints1;
mLines = new Ogre::ManualObject("BulletPhysicsLines1");
mLines2 = new Ogre::ManualObject("BulletPhysicsLines2");
mTriangles = new Ogre::ManualObject("BulletPhysicsTriangles1");
mTriangles2 = new Ogre::ManualObject("BulletPhysicsTriangles2");
mLines->setDynamic(true);
mLines2->setDynamic(true);
mTriangles->setDynamic(true);
mTriangles2->setDynamic(true);
//mLines->estimateVertexCount( 100000 );
//mLines->estimateIndexCount( 0 );
sceneManager->getRootSceneNode()->attachObject(mLines);
sceneManager->getRootSceneNode()->attachObject(mLines2);
sceneManager->getRootSceneNode()->attachObject(mTriangles);
sceneManager->getRootSceneNode()->attachObject(mTriangles2);
static const char* matName = "OgreBulletCollisionsDebugDefault";
Ogre::MaterialPtr mtl =
Ogre::MaterialManager::getSingleton().getDefaultSettings()->clone(
matName);
mtl->setReceiveShadows(false);
mtl->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
mtl->setDepthBias(0.1, 0);
Ogre::TextureUnitState * tu =
mtl->getTechnique(0)->getPass(0)->createTextureUnitState();
tu->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_DIFFUSE);
mtl->getTechnique(0)->setLightingEnabled(false);
//mtl->getTechnique(0)->setSelfIllumination( ColourValue::White );
//for the ogre text
Ogre::Root::getSingleton().addFrameListener(this);
//TODO: Add 3D text writing capability to ogreBtdebugdrawer #133.
// olm = Ogre::OverlayManager::getSingletonPtr();
// panel = static_cast<Ogre::OverlayContainer*>(olm->createOverlayElement(
// "Panel", "OGREBTDEBUGDRAWER_GUI"));
// panel->setMetricsMode(Ogre::GMM_PIXELS);
// panel->setPosition(0, 0);
// panel->setDimensions(1.0f, 1.0f);
// overlay = olm->create("OGREBTDEBUGDRAWER_OVERLAY");
// overlay->add2D(panel);
//
// szElement = "element_";
// overlay = olm->getByName("OGREBTDEBUGDRAWER_OVERLAY");
// panel = static_cast<Ogre::OverlayContainer*>(olm->getOverlayElement(
// "OGREBTDEBUGDRAWER_GUI"));
// textArea =
// static_cast<Ogre::TextAreaOverlayElement*>(olm->createOverlayElement(
// "TextArea", szElement));
// panel->addChild(textArea);
// overlay->show();
}
//----------------------------------------------------------------------------------------
void PortalOutlineRenderable::createPortalMaterials(void)
{
Ogre::ColourValue colour = Ogre::ColourValue(0,1,0);//
Ogre::String matname = "PortalOutlineMaterial";
Ogre::ResourceManager::ResourceCreateOrRetrieveResult result = Ogre::MaterialManager::getSingleton().createOrRetrieve(matname, "General");
if(result.second)
{
Ogre::MaterialPtr freePortalMaterial = result.first;
freePortalMaterial->setReceiveShadows(false);
freePortalMaterial->getTechnique(0)->setLightingEnabled(true);
freePortalMaterial->getTechnique(0)->getPass(0)->setDiffuse(colour);
freePortalMaterial->getTechnique(0)->getPass(0)->setAmbient(colour);
freePortalMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(colour);
}
colour = Ogre::ColourValue(1,1,0);//Yellow
matname = "PortalOutlineMaterialConnected";
result = Ogre::MaterialManager::getSingleton().createOrRetrieve(matname, "General");
if(result.second)
{
Ogre::MaterialPtr connectedPortalMaterial = result.first;
connectedPortalMaterial->setReceiveShadows(false);
connectedPortalMaterial->getTechnique(0)->setLightingEnabled(true);
connectedPortalMaterial->getTechnique(0)->getPass(0)->setDiffuse(colour);
connectedPortalMaterial->getTechnique(0)->getPass(0)->setAmbient(colour);
connectedPortalMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(colour);
}
colour = Ogre::ColourValue(1,0,0);//Red
matname = "PortalOutlineMaterialLinked";
result = Ogre::MaterialManager::getSingleton().createOrRetrieve(matname, "General");
if(result.second)
{
Ogre::MaterialPtr linkedPortalMaterial = result.first;
linkedPortalMaterial->setReceiveShadows(false);
linkedPortalMaterial->getTechnique(0)->setLightingEnabled(true);
linkedPortalMaterial->getTechnique(0)->getPass(0)->setDiffuse(colour);
linkedPortalMaterial->getTechnique(0)->getPass(0)->setAmbient(colour);
linkedPortalMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(colour);
}
}
void createColorMaterial(const std::string& name, const Ogre::ColourValue& color, bool use_self_illumination)
{
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create( name, ROS_PACKAGE_NAME );
mat->setAmbient(color * 0.5f);
mat->setDiffuse(color);
if( use_self_illumination )
{
mat->setSelfIllumination(color);
}
mat->setLightingEnabled(true);
mat->setReceiveShadows(false);
}
VideoVisual::VideoVisual(
const std::string &name, rendering::VisualPtr parent,
int height, int width) :
rendering::Visual(name, parent), height_(height), width_(width)
{
texture_ = Ogre::TextureManager::getSingleton().createManual(
name + "__VideoTexture__",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,
width_, height_,
0,
Ogre::PF_BYTE_BGRA,
Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
Ogre::MaterialPtr material =
Ogre::MaterialManager::getSingleton().create(
name + "__VideoMaterial__", "General");
material->getTechnique(0)->getPass(0)->createTextureUnitState(
name + "__VideoTexture__");
material->setReceiveShadows(false);
double factor = 1.0;
Ogre::ManualObject mo(name + "__VideoObject__");
mo.begin(name + "__VideoMaterial__",
Ogre::RenderOperation::OT_TRIANGLE_LIST);
mo.position(-factor / 2, factor / 2, 0.51);
mo.textureCoord(0, 0);
mo.position(factor / 2, factor / 2, 0.51);
mo.textureCoord(1, 0);
mo.position(factor / 2, -factor / 2, 0.51);
mo.textureCoord(1, 1);
mo.position(-factor / 2, -factor / 2, 0.51);
mo.textureCoord(0, 1);
mo.triangle(0, 3, 2);
mo.triangle(2, 1, 0);
mo.end();
mo.convertToMesh(name + "__VideoMesh__");
Ogre::MovableObject *obj = (Ogre::MovableObject*)
this->GetSceneNode()->getCreator()->createEntity(
name + "__VideoEntity__",
name + "__VideoMesh__");
obj->setCastShadows(false);
this->AttachObject(obj);
}
DebugDrawer::DebugDrawer(Ogre::SceneNode *node, btDynamicsWorld *world) :
mNode(node), mWorld(world), m_debugMode(0)
{
mLineDrawer = new DynamicLines(Ogre::RenderOperation::OT_LINE_LIST);
mLineDrawer->setCastShadows(false); //`
mNode->attachObject(mLineDrawer);
Ogre::ResourceGroupManager::getSingleton().createResourceGroup("BtOgre");
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("BtOgre/DebugLines", "BtOgre");
mat->setReceiveShadows(false);
mat->setLightingEnabled(false);
//mat->setSelfIllumination(1,1,1);
mLineDrawer->setMaterial("BtOgre/DebugLines");/**/ //crash debug..
}
void
setupMaterial() {
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getDefaultSettings()->clone(
MATERIAL_NAME
);
material->setReceiveShadows(false);
material->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
material->setDepthBias(0.1, 0);
Ogre::TextureUnitState* textureUnitState = material->getTechnique(0)->getPass(0)->createTextureUnitState();
textureUnitState->setColourOperationEx(
Ogre::LBX_SOURCE1,
Ogre::LBS_DIFFUSE
);
material->getTechnique(0)->setLightingEnabled(false);
}
void
Player::createHitBox(std::string name)
{
Ogre::ManualObject* myManualObject = mSceneManager->createManualObject(name);
myManualObject->setDynamic(true);
Ogre::SceneNode* myManualObjectNode = mSceneManager->getRootSceneNode()->createChildSceneNode(name + "_node");
Ogre::MaterialPtr myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create(name + "Material","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(1,0,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(1,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1,0,0);
myManualObjectNode->attachObject(myManualObject);
}
std::string createMaterialIfNotExists(const float r, const float g, const float b, const float a)
{
char buf[128];
sprintf(buf, "ShapeColor%f;%f;%f;%f",r,g,b,a);
if(!Ogre::MaterialManager::getSingleton().getByName(buf, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME).isNull())
return buf;
Ogre::ColourValue color( r,g,b,a );
Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create( buf, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
mat->setAmbient(color * 0.01f);
mat->setDiffuse(color);
mat->setLightingEnabled(true);
mat->setReceiveShadows(true);
mat->setCullingMode(Ogre::CULL_NONE);
return buf;
}
void AxisComponent::addMaterial(const Ogre::String &mat, Ogre::ColourValue &clr, Ogre::SceneBlendType sbt)
{
static int init=false;
if(init)
return;
else
init=true;
Ogre::MaterialPtr matptr = Ogre::MaterialManager::getSingleton().create(mat, "General");
matptr->setReceiveShadows(false);
matptr->getTechnique(0)->setLightingEnabled(true);
matptr->getTechnique(0)->getPass(0)->setDiffuse(clr);
matptr->getTechnique(0)->getPass(0)->setAmbient(clr);
matptr->getTechnique(0)->getPass(0)->setSelfIllumination(clr);
matptr->getTechnique(0)->getPass(0)->setSceneBlending(sbt);
matptr->getTechnique(0)->getPass(0)->setLightingEnabled(false);
matptr->getTechnique(0)->getPass(0)->setVertexColourTracking(Ogre::TVC_DIFFUSE);
}
void PolygonArrayDisplay::allocateMaterials(int num)
{
if (only_border_) {
return;
}
static uint32_t count = 0;
if (num > materials_.size()) {
for (size_t i = materials_.size(); num > i; i++) {
std::stringstream ss;
ss << "PolygonArrayMaterial" << count++;
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(ss.str(), "rviz");
material->setReceiveShadows(false);
material->getTechnique(0)->setLightingEnabled(true);
material->getTechnique(0)->setAmbient(0.5, 0.5, 0.5);
materials_.push_back(material);
}
}
}
void OgreModule::initEnd()
{
Ogre::CompositorManager2* compositorManager = mOgreRoot.getCompositorManager2();
compositorManager->createBasicWorkspaceDef("Basic Workspace", Ogre::ColourValue(0.15f, 0.15f, 0.15f));
compositorManager->createBasicWorkspaceDef("Black Workspace", Ogre::ColourValue::Black);
Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialPtr material = materialManager->create("debug_invisible", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
material->setReceiveShadows(false);
Ogre::Pass* pass = material->getTechnique(0)->getPass(0);
#if OGRE_VERSION_MAJOR == 2 && OGRE_VERSION_MINOR > 0
#else
pass->setCullingMode(Ogre::CULL_NONE);
pass->setColourWriteEnabled(false);
pass->setDepthWriteEnabled(false);
#endif
this->loadResources();
}
void RenderWindow::CreateRenderTargetOverlay(int width, int height)
{
width = max(1, width);
height = max(1, height);
Ogre::TexturePtr renderTarget = Ogre::TextureManager::getSingleton().createManual(
rttTextureName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D, width, height, 0, Ogre::PF_A8R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
Ogre::MaterialPtr rttMaterial = Ogre::MaterialManager::getSingleton().create(
rttMaterialName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Ogre::TextureUnitState *rttTuState = rttMaterial->getTechnique(0)->getPass(0)->createTextureUnitState();
rttTuState->setTextureName(rttTextureName);
rttTuState->setTextureFiltering(Ogre::TFO_NONE);
rttTuState->setNumMipmaps(1);
rttTuState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
rttMaterial->setFog(true, Ogre::FOG_NONE); ///\todo Check, shouldn't here be false?
rttMaterial->setReceiveShadows(false);
rttMaterial->setTransparencyCastsShadows(false);
rttMaterial->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA);
rttMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false);
rttMaterial->getTechnique(0)->getPass(0)->setCullingMode(Ogre::CULL_NONE);
overlayContainer = Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "MainWindow Overlay Panel");
overlayContainer->setMaterialName(rttMaterialName);
overlayContainer->setMetricsMode(Ogre::GMM_PIXELS);
overlayContainer->setPosition(0, 0);
overlayContainer->setDimensions((Ogre::Real)width, (Ogre::Real)height);
overlayContainer->setPosition(0,0);
overlay = Ogre::OverlayManager::getSingleton().create("MainWindow Overlay");
overlay->add2D(static_cast<Ogre::OverlayContainer *>(overlayContainer));
overlay->setZOrder(500);
overlay->show();
// ResizeOverlay(width, height);
}
void McsHudGui::addFrameGraph(CEGUI::Window* sheet)
{
Ogre::TexturePtr tex = mOgreRoot->getTextureManager()->createManual(
"FrameGraph", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,
TimeGraphMaxFrames, TimeGraphMaxResolution, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET);
Ogre::SceneManager* debugSceneMgr = mOgreRoot->createSceneManager(Ogre::ST_GENERIC);
debugSceneMgr->setAmbientLight(Ogre::ColourValue(1.0f, 1.0f, 1.0f));
Ogre::MaterialPtr frameLinesMaterial = Ogre::MaterialManager::getSingleton().create("frameLinesMaterial","Game");
frameLinesMaterial->setReceiveShadows(false);
frameLinesMaterial->getTechnique(0)->setLightingEnabled(false);
frameLinesMaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false);
frameLinesMaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false);
mFrameLines = new FrameGraphRenderable(TimeGraphMaxFrames, TimeGraphMaxResolution);
mFrameLines->setMaterial("frameLinesMaterial");
Ogre::SceneNode* frameLinesNode = debugSceneMgr->getRootSceneNode()->createChildSceneNode("frameGraph_node");
frameLinesNode->attachObject(mFrameLines);
Ogre::Camera* dbg_camera = debugSceneMgr->createCamera("item_camera");
dbg_camera->setAspectRatio(static_cast<Ogre::Real>(TimeGraphMaxFrames) / static_cast<Ogre::Real>(TimeGraphMaxResolution));
Ogre::Viewport *v = tex->getBuffer()->getRenderTarget()->addViewport(dbg_camera);
v->setClearEveryFrame( true );
v->setBackgroundColour( Ogre::ColourValue::Black );
CEGUI::Texture& guiTex = mCeRenderer->createTexture(tex);
CEGUI::Imageset& imageSet = CEGUI::ImagesetManager::getSingleton().create("FrameGraphImageset", guiTex);
imageSet.defineImage("FrameGraphImage", CEGUI::Point(0.0f, 0.0f), CEGUI::Size(guiTex.getSize()), CEGUI::Point(0.0f, 0.0f));
CEGUI::Window* si = CEGUI::WindowManager::getSingleton().createWindow("TaharezLook/StaticImage", "FrameGraphWindow");
si->setSize(CEGUI::UVector2(CEGUI::UDim(0.0f, TimeGraphMaxFrames), CEGUI::UDim(0.0f, TimeGraphMaxResolution)));
si->setPosition(CEGUI::UVector2(CEGUI::UDim(0.0f, 0), CEGUI::UDim(1.0f, -TimeGraphMaxResolution)));
si->setProperty("Image", CEGUI::PropertyHelper::imageToString(&imageSet.getImage("FrameGraphImage")));
si->setAlpha(0.6f);
si->setProperty("BackgroundEnabled", "False");
si->setProperty("FrameEnabled", "False");
sheet->addChildWindow(si);
}
void MainApplication::shoot()
{
Ogre::String number2 = Ogre::StringConverter::toString(shotCounter + 1);
shots.push_back("manual1_node" + number2);
/*
Ogre::Entity* ogreHead = mSceneMgr -> createEntity("ogrehead.mesh");
Ogre::SceneNode *headNode = mSceneMgr -> getRootSceneNode() -> createChildSceneNode("manual1_node" + number2);
Ogre::Vector3 pos1(mSceneMgr-> getSceneNode("NinjaNode")->getPosition());
headNode -> setPosition(pos1);
headNode -> attachObject(ogreHead);
*/
Ogre::ManualObject* myManualObject = mSceneMgr->createManualObject("manual1" + number2);
Ogre::SceneNode* myManualObjectNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("manual1_node" + number2);
// NOTE: The second parameter to the create method is the resource group the material will be added to.
// If the group you name does not exist (in your resources.cfg file) the library will assert() and your program will crash
Ogre::MaterialPtr myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("manual1Material","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,0,1,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(0,0,1);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,0,1);
//myManualObjectMaterial->dispose(); // dispose pointer, not the material
Ogre::Vector3 pos1(mSceneMgr-> getSceneNode("NinjaNode")->getPosition());//Get position of player
myManualObject->begin("manual1Material", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject->position(pos1.x + 20, pos1.y, pos1.z);
myManualObject->position(pos1.x + 50, pos1.y, pos1.z);
// etc
myManualObject->end();
myManualObjectNode->attachObject(myManualObject);
shotCounter++;
}
CFootballPlayer::CFootballPlayer(CSimulationManager *simulationManager, const CPfTeamPlayers *teamPlayer, int number, CTeam *team, bool sideLeft)
:CMovingEntity()
{
m_simulationManager = simulationManager;
Ogre::SceneManager *scnMgr = Ogre::Root::getSingletonPtr()->getSceneManager(SIMULATION_SCENE_MANAGER_NODE_NAME);
m_teamPlayer = new CPfTeamPlayers(*teamPlayer);
m_stateMachine = new CStateMachine<CFootballPlayer>(this);
Ogre::String id;
char charId[20];
m_centerOfMassOffset.setOrigin(btVector3(0,-0.9,0));
m_sideLeft = sideLeft;
m_team = team;
m_number = number; //TODO
m_lastKickBallCycle = -1;
//m_direction.normalize();
sprintf(charId,"%s%d", team->getName().c_str(), m_number);
id = charId;
m_entity = scnMgr->createEntity("Player"+id, "Human.mesh");
if(sideLeft) {
if(m_number == 1) {
m_entity->setMaterialName("goalie_red");
} else {
m_entity->setMaterialName("player_red");
}
} else {
if(m_number == 1) {
m_entity->setMaterialName("goalie_yellow");
} else {
m_entity->setMaterialName("player_yellow");
}
}
btVector3 *initialPos = team->getPlayerStrategicPosition(m_number)->getInitialPosition();
btVector3 pos(initialPos->x(), initialPos->y(), initialPos->z());
if(!m_sideLeft) {
pos.setX(-pos.x());
pos.setZ(-pos.z());
}
m_node = scnMgr->getRootSceneNode()->createChildSceneNode("PlayerNode"+id, Ogre::Vector3(pos.x(), pos.y(), pos.z()));
m_node->attachObject(m_entity);
m_shape = new btCylinderShape(btVector3(btScalar(0.5),btScalar(0.9),btScalar(0.5)));
btScalar mass(70.0);
//rigidbody is dynamic if and only if mass is non zero, otherwise static
bool isDynamic = (mass != 0.f);
btVector3 localInertia(0,0,0);
if (isDynamic)
m_shape->calculateLocalInertia(mass,localInertia);
btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,this,m_shape,localInertia);
m_body = new btRigidBody(rbInfo);
m_body->setAngularFactor(btScalar(0));
m_body->setActivationState(DISABLE_DEACTIVATION);
m_steeringBehavior = new CSteeringBehaviors(this);
//Draw Circle
Ogre::ManualObject * circle = scnMgr->createManualObject("circle_name"+id);
float const radius = 1.5,
thickness = 0.7, // Of course this must be less than the radius value.
accuracy = 5,
height = 0.01;
Ogre::MaterialPtr matptr;
Ogre::Pass* pass;
if(sideLeft) {
matptr = Ogre::MaterialManager::getSingleton().createOrRetrieve("Red"+id, "General").first;
matptr->setReceiveShadows(true);
pass = matptr->getTechnique(0)->getPass(0);
Ogre::ColourValue colour = Ogre::ColourValue::Red;
pass->setDiffuse(colour);
pass->setAmbient(colour);
pass->setSpecular(colour);
pass->setSelfIllumination(colour);
//pass->setEmissive(ColourValue(0,0,0,colour.a));
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
} else {
matptr = Ogre::MaterialManager::getSingleton().createOrRetrieve("Blue"+id, "General").first;
matptr->setReceiveShadows(true);
pass = matptr->getTechnique(0)->getPass(0);
Ogre::ColourValue colour = Ogre::ColourValue::Blue;
pass->setDiffuse(colour);
pass->setAmbient(colour);
pass->setSpecular(colour);
pass->setSelfIllumination(colour);
//pass->setEmissive(ColourValue(0,0,0,colour.a));
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
}
circle->begin(matptr->getName(), Ogre::RenderOperation::OT_TRIANGLE_LIST);
unsigned point_index = 0;
for(float theta = 0; theta <= 2 * Ogre::Math::PI; theta += Ogre::Math::PI / (radius * accuracy)) {
circle->position(radius * cos(theta),
height,
radius * sin(theta));
circle->position(radius * cos(theta - Ogre::Math::PI / (radius * accuracy)),
height,
radius * sin(theta - Ogre::Math::PI / (radius * accuracy)));
circle->position((radius - thickness) * cos(theta - Ogre::Math::PI / (radius * accuracy)),
height,
(radius - thickness) * sin(theta - Ogre::Math::PI / (radius * accuracy)));
circle->position((radius - thickness) * cos(theta),
height,
(radius - thickness) * sin(theta));
// Join the 4 vertices created above to form a quad.
circle->quad(point_index, point_index + 1, point_index + 2, point_index + 3);
point_index += 4;
}
circle->end();
m_ringNode = m_node->createChildSceneNode();
m_ringNode->attachObject(circle);
}
//-------------------------------------------------------------------------------------
void TutorialApplication::createScene(void)
{
// Set the scene's ambient light
mSceneMgr->setAmbientLight(Ogre::ColourValue(0.5f, 0.5f, 0.5f));
// Create an Entity
Ogre::Entity* ogreHead = mSceneMgr->createEntity("Head", "ogrehead.mesh");
// Create a SceneNode and attach the Entity to it
Ogre::SceneNode* headNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("HeadNode");
headNode->attachObject(ogreHead);
headNode->setPosition(0, 25, 0);
headNode->roll(Ogre::Radian(0.5));
Ogre::ManualObject* myManualObject = mSceneMgr->createManualObject("manual1");
Ogre::ManualObject* myManualObject2 = mSceneMgr->createManualObject("manual2");
Ogre::SceneNode* myManualObjectNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("manual1_node");
Ogre::SceneNode* myManualObjectNode2 = mSceneMgr->getRootSceneNode()->createChildSceneNode("manual2_node");
// NOTE: The second parameter to the create method is the resource group the material will be added to.
// If the group you name does not exist (in your resources.cfg file) the library will assert() and your program will crash
Ogre::MaterialPtr myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("blueMaterial","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,0,1,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(0,0,1);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,0,1);
myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("greenMaterial","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,1,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(0,1,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,1,0);
myManualObjectMaterial = Ogre::MaterialManager::getSingleton().create("redMaterial","General");
myManualObjectMaterial->setReceiveShadows(false);
myManualObjectMaterial->getTechnique(0)->setLightingEnabled(true);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setDiffuse(1,0,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setAmbient(1,0,0);
myManualObjectMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(1,0,0);
myManualObject->begin("blueMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject->position(0, 0, 0);
myManualObject->position(50, 0, 0);
myManualObject->end();
myManualObject->begin("greenMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject->position(0, 0, 0);
myManualObject->position(0, 70, 0);
myManualObject->end();
myManualObject->begin("redMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject->position(0, 0, 0);
myManualObject->position(0, 0, 50);
myManualObject->end();
myManualObjectNode->attachObject(myManualObject);
myManualObject2->begin("blueMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject2->position(0, 0, 0);
myManualObject2->position(50, 0, 0);
myManualObject2->end();
myManualObject2->begin("greenMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject2->position(0, 0, 0);
myManualObject2->position(0, 70, 0);
myManualObject2->end();
myManualObject2->begin("redMaterial", Ogre::RenderOperation::OT_LINE_LIST);
myManualObject2->position(0, 0, 0);
myManualObject2->position(0, 0, 50);
myManualObject2->end();
myManualObjectNode2->attachObject(myManualObject2);
myManualObjectNode2->roll(Ogre::Radian(0.5));
// Create a Light and set its position
Ogre::Light* light = mSceneMgr->createLight("MainLight");
light->setPosition(20.0f, 80.0f, 50.0f);
}
void gkMaterialLoader::loadSubMeshMaterial(gkSubMesh* mesh, const gkString& group)
{
using namespace Ogre;
gkMaterialProperties& gma = mesh->getMaterial();
if (gma.m_name.empty())
gma.m_name = "<gkBuiltin/DefaultMaterial>";
Ogre::MaterialPtr oma = Ogre::MaterialManager::getSingleton().getByName(gma.m_name.c_str(), group);
if (!oma.isNull())
return;
oma = Ogre::MaterialManager::getSingleton().create(gma.m_name, group);
if (gma.m_mode & gkMaterialProperties::MA_INVISIBLE)
{
// disable writing to this material
oma->setReceiveShadows(false);
oma->setColourWriteEnabled(false);
oma->setDepthWriteEnabled(false);
oma->setDepthCheckEnabled(false);
oma->setLightingEnabled(false);
return;
}
if (gma.m_mode & gkMaterialProperties::MA_TWOSIDE)
{
oma->setCullingMode(Ogre::CULL_NONE);
oma->setManualCullingMode(Ogre::MANUAL_CULL_NONE);
}
// apply lighting params
bool enableLights = (gma.m_mode & gkMaterialProperties::MA_LIGHTINGENABLED) != 0;
oma->setReceiveShadows((gma.m_mode & gkMaterialProperties::MA_RECEIVESHADOWS) != 0);
oma->setLightingEnabled(enableLights);
if (enableLights)
{
gkColor emissive, ambient, specular, diffuse;
emissive = gma.m_diffuse * gma.m_emissive;
ambient = gma.m_diffuse * gma.m_ambient;
specular = gma.m_specular * gma.m_spec;
diffuse = gma.m_diffuse * (gma.m_emissive + gma.m_refraction);
emissive.a = ambient.a = specular.a = 1.f;
oma->setSelfIllumination(emissive);
oma->setAmbient(ambient);
oma->setSpecular(specular);
oma->setDiffuse(diffuse);
oma->setShininess(gma.m_hardness);
}
Ogre::Pass* pass = oma->getTechnique(0)->getPass(0);
bool matBlending = gkEngine::getSingleton().getUserDefs().matblending;
if (matBlending && (gma.m_mode & gkMaterialProperties::MA_HASRAMPBLEND))
{
switch (gma.m_rblend)
{
case GK_BT_MULTIPLY:
pass->setSceneBlending(SBT_MODULATE);
break;
case GK_BT_SUBTRACT:
pass->setSceneBlending(SBF_ONE_MINUS_SOURCE_COLOUR, SBF_ONE);
break;
case GK_BT_DARKEN:
pass->setSceneBlendingOperation(SBO_MIN);
pass->setSceneBlending(SBF_ONE, SBF_ONE);
break;
case GK_BT_LIGHTEN:
pass->setSceneBlendingOperation(SBO_MAX);
pass->setSceneBlending(SBF_ONE, SBF_ONE);
break;
case GK_BT_SCREEN:
pass->setSceneBlending(SBF_ONE_MINUS_DEST_COLOUR, SBF_ONE);
break;
case GK_BT_ADDITIVE:
pass->setSceneBlending(SBT_ADD);
break;
case GK_BT_MIXTURE:
default:
pass->setSceneBlending(SBF_ONE, SBF_ZERO);
break;
}
}
bool hasNormap = false;
bool rtss = gkEngine::getSingleton().getUserDefs().rtss;
for (int i = 0; i < gma.m_totaltex; ++i)
{
gkTextureProperties& gte = gma.m_textures[i];
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
if (gte.m_mode & gkTextureProperties::TM_NORMAL)
{
hasNormap = true;
continue;
}
#endif
Ogre::TextureUnitState* otus = pass->createTextureUnitState(gte.m_name, gte.m_layer);
LayerBlendOperationEx op = LBX_MODULATE;
switch (gte.m_blend)
{
case GK_BT_ADDITIVE:
op = LBX_ADD;
break;
case GK_BT_SUBTRACT:
op = LBX_SUBTRACT;
break;
case GK_BT_DARKEN:
case GK_BT_LIGHTEN:
case GK_BT_SCREEN:
case GK_BT_COLOR:
//break; TODO: support more mode
case GK_BT_MULTIPLY:
case GK_BT_MIXTURE:
default:
op = LBX_MODULATE;
break;
}
if (i == 0)
otus->setColourOperationEx(op, LBS_DIFFUSE, LBS_TEXTURE);
else
otus->setColourOperationEx(op);
otus->setTextureScale(gte.m_scale[0],gte.m_scale[1]);
}
if (gma.m_mode & gkMaterialProperties::MA_ALPHABLEND)
{
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setDepthWriteEnabled(false);
}
if (gma.m_mode & gkMaterialProperties::MA_ALPHACLIP)
{
pass->setAlphaRejectSettings(Ogre::CMPF_GREATER_EQUAL, 254);
}
#ifdef OGREKIT_USE_RTSHADER_SYSTEM
if (rtss)
{
//pass->setSpecular(ColourValue::Black);
//pass->setShininess(0.0);
RTShader::RenderState* rs = 0;
RTShader::ShaderGenerator* sg = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
bool ok = sg->createShaderBasedTechnique(gma.m_name, group,
Ogre::MaterialManager::DEFAULT_SCHEME_NAME, Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
if (ok && hasNormap)
{
rs = sg->getRenderState(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, gma.m_name, 0);
rs->reset();
for (int i = 0; i < gma.m_totaltex; ++i)
{
gkTextureProperties& gte = gma.m_textures[i];
if (gte.m_mode & gkTextureProperties::TM_NORMAL)
{
GK_ASSERT(rs);
RTShader::SubRenderState* srs= sg->createSubRenderState(RTShader::NormalMapLighting::Type);
RTShader::NormalMapLighting* nsrs = static_cast<RTShader::NormalMapLighting*>(srs);
if (gte.m_texmode & gkTextureProperties::TX_OBJ_SPACE)
nsrs->setNormalMapSpace(RTShader::NormalMapLighting::NMS_OBJECT);
else
nsrs->setNormalMapSpace(RTShader::NormalMapLighting::NMS_TANGENT);
nsrs->setNormalMapTextureName(gte.m_name);
nsrs->setTexCoordIndex(gte.m_layer);
rs->addTemplateSubRenderState(srs);
}
}
sg->invalidateMaterial(RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME, gma.m_name);
}
}
#endif
}
void EC_OgreSky::CreateSky(bool show)
{
if (renderer_.expired())
return;
RendererPtr renderer = renderer_.lock();
DisableSky();
Ogre::SceneManager* scene_mgr = renderer->GetSceneManager();
/*RexTypes::Vector3 v = genericSkyParameters.angleAxis;
Ogre::Quaternion orientation(Ogre::Degree(genericSkyParameters.angle), Ogre::Vector3(v.x, v.y, v.z));*/
///\todo Get the sky type and other parameters from the config file.
switch(type_)
{
case SKYTYPE_BOX:
{
Ogre::MaterialPtr skyMaterial = Ogre::MaterialManager::getSingleton().getByName(skyBoxParameters.material);
skyMaterial->setReceiveShadows(false);
try
{
RexTypes::Vector3 v = skyBoxParameters.angleAxis;
Ogre::Quaternion orientation(Ogre::Degree(skyBoxParameters.angle), Ogre::Vector3(v.x, v.y, v.z));
scene_mgr->setSkyBox(show, skyBoxParameters.material, skyBoxParameters.distance, skyBoxParameters.drawFirst, orientation);
}
catch (Ogre::Exception& e)
{
OgreRenderingModule::LogError("Could not set SkyBox: " + std::string(e.what()));
return;
}
skyEnabled_ = true;
break;
}
case SKYTYPE_DOME:
try
{
RexTypes::Vector3 v = skyDomeParameters.angleAxis;
Ogre::Quaternion orientation(Ogre::Degree(skyDomeParameters.angle), Ogre::Vector3(v.x, v.y, v.z));
scene_mgr->setSkyDome(show, skyDomeParameters.material, skyDomeParameters.curvature, skyDomeParameters.tiling,
skyDomeParameters.distance, skyDomeParameters.drawFirst, orientation, skyDomeParameters.xSegments,
skyDomeParameters.ySegments, skyDomeParameters.ySegmentsKeep);
}
catch (Ogre::Exception& e)
{
OgreRenderingModule::LogError("Could not set SkyDome: " + std::string(e.what()));
return;
}
skyEnabled_ = true;
break;
case SKYTYPE_PLANE:
try
{
///\todo
Ogre::Plane plane;
plane.d = skyPlaneParameters.distance;
plane.normal = Ogre::Vector3::NEGATIVE_UNIT_Z;
scene_mgr->setSkyPlane(true, plane, skyPlaneParameters.material, skyPlaneParameters.scale, skyPlaneParameters.tiling, true,
skyPlaneParameters.bow, skyPlaneParameters.xSegments, skyPlaneParameters.ySegments);
}
catch (Ogre::Exception& e)
{
OgreRenderingModule::LogError("Could not set SkyPlane: " + std::string(e.what()));
return;
}
skyEnabled_ = true;
break;
case SKYTYPE_NONE:
default:
skyEnabled_ = false;
break;
}
}
void AerialMapDisplay::assembleScene() {
if (!dirty_) {
return; // nothing to update
}
dirty_ = false;
if (!loader_) {
return; // no tiles loaded, don't do anything
}
// get rid of old geometry, we will re-build this
clearGeometry();
// iterate over all tiles and create an object for each of them
const double resolution = loader_->resolution();
const std::vector<TileLoader::MapTile> &tiles = loader_->tiles();
for (const TileLoader::MapTile &tile : tiles) {
const int w = tile.image().width();
const int h = tile.image().height();
// we here assume that the tiles are uniformly sized...
const double tileW = w * resolution;
const double tileH = h * resolution;
const double origin_x = -loader_->originX() * tileW;
const double origin_y = -(1 - loader_->originY()) * tileH;
// determine location of this tile
const double x = (tile.x() - loader_->tileX()) * tileW + origin_x;
const double y = -(tile.y() - loader_->tileY()) * tileH + origin_y;
// don't re-use any ids
const std::string name_suffix =
std::to_string(tile.x()) + "_" + std::to_string(tile.y()) + "_" +
std::to_string(map_id_) + "_" + std::to_string(scene_id_);
Ogre::TexturePtr tex;
if (tile.hasImage()) {
// one material per texture
std::string matName = "material_" + name_suffix;
Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(
matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
material->setReceiveShadows(false);
material->getTechnique(0)->setLightingEnabled(false);
material->setDepthBias(-16.0f,
0.0f); /// @todo: what the f**k does this do?
material->setCullingMode(Ogre::CULL_NONE);
material->setDepthWriteEnabled(false);
// create textureing unit
Ogre::Pass *pass = material->getTechnique(0)->getPass(0);
Ogre::TextureUnitState *tex_unit = NULL;
if (pass->getNumTextureUnitStates() > 0) {
tex_unit = pass->getTextureUnitState(0);
} else {
tex_unit = pass->createTextureUnitState();
}
// only add if we have a texture for it
tex = textureFromImage(tile.image(), "texture_" + name_suffix);
ROS_INFO("Rendering with texture: %s", tex->getName().c_str());
tex_unit->setTextureName(tex->getName());
tex_unit->setTextureFiltering(Ogre::TFO_BILINEAR);
// create an object
const std::string obj_name = "object_" + name_suffix;
Ogre::ManualObject *obj = scene_manager_->createManualObject(obj_name);
scene_node_->attachObject(obj);
// configure depth & alpha properties
if (alpha_ >= 0.9998) {
material->setDepthWriteEnabled(!draw_under_);
material->setSceneBlending(Ogre::SBT_REPLACE);
} else {
material->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
material->setDepthWriteEnabled(false);
}
if (draw_under_) {
obj->setRenderQueueGroup(Ogre::RENDER_QUEUE_4);
} else {
obj->setRenderQueueGroup(Ogre::RENDER_QUEUE_MAIN);
}
tex_unit->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_MANUAL,
Ogre::LBS_CURRENT, alpha_);
// create a quad for this tile
obj->begin(material->getName(), Ogre::RenderOperation::OT_TRIANGLE_LIST);
// bottom left
obj->position(x, y, 0.0f);
obj->textureCoord(0.0f, 0.0f);
obj->normal(0.0f, 0.0f, 1.0f);
// top right
obj->position(x + tileW, y + tileH, 0.0f);
obj->textureCoord(1.0f, 1.0f);
obj->normal(0.0f, 0.0f, 1.0f);
// top left
obj->position(x, y + tileH, 0.0f);
obj->textureCoord(0.0f, 1.0f);
obj->normal(0.0f, 0.0f, 1.0f);
// bottom left
obj->position(x, y, 0.0f);
obj->textureCoord(0.0f, 0.0f);
obj->normal(0.0f, 0.0f, 1.0f);
// bottom right
obj->position(x + tileW, y, 0.0f);
obj->textureCoord(1.0f, 0.0f);
obj->normal(0.0f, 0.0f, 1.0f);
// top right
obj->position(x + tileW, y + tileH, 0.0f);
obj->textureCoord(1.0f, 1.0f);
obj->normal(0.0f, 0.0f, 1.0f);
obj->end();
if (draw_under_property_->getValue().toBool()) {
// render under everything else
obj->setRenderQueueGroup(Ogre::RENDER_QUEUE_4);
}
MapObject object;
object.object = obj;
object.texture = tex;
object.material = material;
objects_.push_back(object);
}
}
scene_id_++;
}
void OgreWidget::initializeOgre()
{
mOgreRoot = new Ogre::Root;
Ogre::RenderSystem *renderSystem = mOgreRoot->getRenderSystemByName("OpenGL Rendering Subsystem");
mOgreRoot->setRenderSystem(renderSystem);
mOgreRoot->initialise(false);
Ogre::NameValuePairList viewConfig;
QWidget *parentWidget = dynamic_cast <QWidget *>(parent());
Ogre::String windowHandle = Ogre::StringConverter::toString ((unsigned long)QX11Info::display()) +
":" + Ogre::StringConverter::toString ((unsigned int)QX11Info::appScreen()) +
":" + Ogre::StringConverter::toString ((unsigned long)parentWidget->winId());
qDebug() << __PRETTY_FUNCTION__ << "using window handle" << QString::fromStdString(windowHandle);
viewConfig["parentWindowHandle"] = windowHandle;
viewConfig["vsync"] = "true"; // this actually works on linux/nvidia-blob/thinkpad!
mOgreRenderWindow = mOgreRoot->createRenderWindow("OgreRenderWindow", width(), height(), false, &viewConfig);
mOgreRenderWindow->setActive(true);
Ogre::SceneManagerEnumerator::MetaDataIterator iter = Ogre::SceneManagerEnumerator::getSingleton().getMetaDataIterator();
while( iter.hasMoreElements() )
{
Ogre::String st = iter.getNext()->typeName;
qDebug() << "Scene manager type available:" << QString::fromStdString(st);
}
mSceneManager = mOgreRoot->createSceneManager(Ogre::ST_GENERIC);
// ogreSceneManager = ogreRoot->createSceneManager("TerrainSceneManager"/*Ogre::ST_EXTERIOR_CLOSE*/);
// ogreSceneManager->showBoundingBoxes(true);
// By default, entities cannot be found using a RSQ. This is to make sure that the
// Lidar's don't catch the rotors, cameras etc. It also means we'll have to set the
// flags to nonzero for any mesh that should be scannable.
Ogre::MovableObject::setDefaultQueryFlags(0x00000000);
mCamera = mSceneManager->createCamera("camera");
mCamera->setNearClipDistance(.1);
//mCamera->setPolygonMode(Ogre::PM_WIREFRAME); /* wireframe */
mCamera->setPolygonMode(Ogre::PM_SOLID); /* solid */
mCameraNode = mSceneManager->getRootSceneNode()->createChildSceneNode("CameraNode", Ogre::Vector3(0, 12, 15));
mCameraNode->attachObject(mCamera);
mCamera->lookAt(0,8,0);
mOgreViewport = mOgreRenderWindow->addViewport(mCamera);
mOgreViewport->setBackgroundColour(Ogre::ColourValue(0.7, 0.7, 0.7));
mCamera->setAspectRatio(Ogre::Real(width()) / Ogre::Real(height()));
if(mOgreRoot->getRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_INFINITE_FAR_PLANE))
{
mCamera->setFarClipDistance(0); // enable infinite far clip distance if we can
}
// Initialize shader generator.
// Must be before resource loading in order to allow parsing extended material attributes.
if(!initializeRTShaderSystem(mSceneManager))
{
OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
"Shader Generator Initialization failed - Core shader libs path not found",
"SdkSample::_setup");
}
setupTerrain();
// initialize trajectory line
mTrajectoryLine = mSceneManager->createManualObject(QString("trajectoryLine_manualobject").toStdString());
Ogre::SceneNode* mTrajectoryLineNode = mSceneManager->getRootSceneNode()->createChildSceneNode("trajectoryLine_node");
Ogre::MaterialPtr trajectoryLineMaterial = Ogre::MaterialManager::getSingleton().create("trajectoryLineMaterial", "General");
trajectoryLineMaterial->setReceiveShadows(false);
trajectoryLineMaterial->getTechnique(0)->setLightingEnabled(true);
trajectoryLineMaterial->getTechnique(0)->getPass(0)->setDiffuse(0,0,1,0);
trajectoryLineMaterial->getTechnique(0)->getPass(0)->setAmbient(0,0,1);
trajectoryLineMaterial->getTechnique(0)->getPass(0)->setSelfIllumination(0,0,1);
// trajectoryLineMaterial->dispose(); // dispose pointer, not the material
mTrajectoryLineNode->attachObject(mTrajectoryLine);
emit setupFinished();
qDebug() << __PRETTY_FUNCTION__ << "done.";
}