GPUSurfFeatureDetector::GPUSurfFeatureDetector(Ogre::Cuda::Root* root, int nbOctave, int nbFeatureMax) : mCudaRoot(root) { mOgreIsAllocated = false; mCudaIsAllocated = false; mWidth = 0; mHeight = 0; mNbFeatureMax = nbFeatureMax; mNbOctave = nbOctave; mThreshold = 0.003f; mNbFeatureFound = 0; mGPGPURoot = new Ogre::GPGPU::Root; mWebcamTexture = Ogre::TextureManager::getSingleton().createManual("WebcamVideoTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, 640, 480, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET); //Create Webcam Material Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("WebcamVideoMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique *technique = material->createTechnique(); technique->createPass(); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); material->getTechnique(0)->getPass(0)->createTextureUnitState("WebcamVideoTexture"); }
//-------------------------------------------------------------------------------- void MaterialUtil::updateSelectedVersion(const MaterialPtr& _material) { String name = _material->getName(); String selName = getSelectedVersionName(name); MaterialPtr material, selectedMaterial; if(selName == name) { name = getUnselectedVersionName(selName); selectedMaterial = _material; material = MaterialManager::getSingleton().getByName(name); } else { material = _material; selectedMaterial = MaterialManager::getSingleton().getByName(selName); } if(!material.isNull() && !selectedMaterial.isNull()) { material->copyDetailsTo(selectedMaterial); Ogre::Technique* technique = selectedMaterial->getBestTechnique(); Pass* pass0 = technique->getPass(0); Pass* passNew = technique->createPass(); passNew->setDiffuse(1, 1, 1, 1); passNew->setPolygonMode(Ogre::PM_WIREFRAME); if(pass0->getNumTextureUnitStates() != 0) { Ogre::TextureUnitState* tu = pass0->getTextureUnitState(0); tu->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_TEXTURE, Ogre::LBS_MANUAL, ColourValue::White, ColourValue(1, 0.6f, 0.6f, 1)); } } }
bool Simple::compileMaterial(Ogre::MaterialPtr material) { material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); for (SurfaceLayerStore::const_iterator I = mTerrainPageSurfaces.begin(); I != mTerrainPageSurfaces.end(); ++I) { const TerrainPageSurfaceLayer* surfaceLayer = I->second; if (I == mTerrainPageSurfaces.begin()) { Ogre::Pass* pass = technique->createPass(); pass->setLightingEnabled(false); //add the first layer of the terrain, no alpha or anything Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale()); textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName()); textureUnitState->setTextureCoordSet(0); } else { if (surfaceLayer->intersects(*mGeometry)) { addPassToTechnique(*mGeometry, technique, surfaceLayer); } } } if (mTerrainPageShadow) { addShadow(technique, mTerrainPageShadow, material); } material->load(); if (material->getNumSupportedTechniques() == 0) { S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation()); return false; } return true; }
bool Simple::compileMaterial(Ogre::MaterialPtr material, std::set<std::string>& managedTextures) const { material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); if (!mTerrainPageSurfaces.empty()) { //First add a base pass auto surfaceLayer = mTerrainPageSurfaces.begin()->second; Ogre::Pass* pass = technique->createPass(); pass->setLightingEnabled(false); Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState(); textureUnitState->setTextureScale(1.0f / surfaceLayer->getScale(), 1.0f / surfaceLayer->getScale()); textureUnitState->setTextureName(surfaceLayer->getDiffuseTextureName()); textureUnitState->setTextureCoordSet(0); for (auto& layer : mLayers) { addPassToTechnique(*mGeometry, technique, layer, managedTextures); } } if (mTerrainPageShadow) { addShadow(technique, mTerrainPageShadow, material, managedTextures); } // addLightingPass(technique, managedTextures); material->load(); if (material->getNumSupportedTechniques() == 0) { S_LOG_WARNING("The material '" << material->getName() << "' has no supported techniques. The reason for this is: \n" << material->getUnsupportedTechniquesExplanation()); return false; } return true; }
bool OgreARAppLogic::initAR() { //INIT Realidad aumentada if ( !userInit(this) ) return false; // user defined function to init AR if(mWidth==0 || mHeight==0 || mBuffer==0) { std::cout << "Image size or buffer not defined in user-defined init function" << std::endl; return false; } // create background texture mPixelBox = Ogre::PixelBox(mWidth, mHeight, 1, Ogre::PF_R8G8B8, mBuffer); // Create Texture mTexture = Ogre::TextureManager::getSingleton().createManual( "CameraTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mWidth, mHeight, 0, Ogre::PF_R8G8B8, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); //Create Camera Material MaterialPtr material = MaterialManager::getSingleton().create("CameraMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique *technique = material->createTechnique(); technique->createPass(); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture"); return true; }
//----------------------------------------------------------------------- Ogre::TextureUnitState* MaterialTab::forceCreateFirstTexture(const Ogre::String textureName) { // Ignore some materials because they result in a crash while unloading wxString materialName = mMaterialListBox->GetStringSelection(); if (materialName == wxT("DefaultSettings")) return 0; Ogre::Technique* technique = 0; Ogre::TextureUnitState* texture = 0; Ogre::Pass* pass = getFirstPass(); if (pass) { // There is a pass, check for textures or create one if (pass->getNumTextureUnitStates() > 0) { pass->removeAllTextureUnitStates(); } texture = pass->createTextureUnitState(textureName); } else { // There is no pass wxString materialName = mMaterialListBox->GetStringSelection(); Ogre::String name = wx2ogre(materialName); Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().getByName(name); if (!material.isNull()) { material->load(); if (material->getNumTechniques() > 0) { technique = material->getBestTechnique(); // Get the best technique pass = technique->createPass(); texture = pass->createTextureUnitState(textureName); } else { // There is no technique, no pass and no textureunitstate technique = material->createTechnique(); pass = technique->createPass(); texture = pass->createTextureUnitState(textureName); } } } return texture; }
Ogre::Technique* GBufferSchemeHandler::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend) { Ogre::MaterialManager& matMgr = Ogre::MaterialManager::getSingleton(); Ogre::String curSchemeName = matMgr.getActiveScheme(); matMgr.setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME); Ogre::Technique* originalTechnique = originalMaterial->getBestTechnique(lodIndex, rend); matMgr.setActiveScheme(curSchemeName); Ogre::Technique* gBufferTech = originalMaterial->createTechnique(); gBufferTech->removeAllPasses(); gBufferTech->setSchemeName(schemeName); Ogre::Technique* noGBufferTech = originalMaterial->createTechnique(); noGBufferTech->removeAllPasses(); noGBufferTech->setSchemeName("NoGBuffer"); for (unsigned short i=0; i<originalTechnique->getNumPasses(); i++) { Ogre::Pass* originalPass = originalTechnique->getPass(i); PassProperties props = inspectPass(originalPass, lodIndex, rend); if (!props.isDeferred) { //Just copy the technique so it gets rendered regularly Ogre::Pass* clonePass = noGBufferTech->createPass(); *clonePass = *originalPass; continue; } Ogre::Pass* newPass = gBufferTech->createPass(); MaterialGenerator::Perm perm = getPermutation(props); const Ogre::MaterialPtr& templateMat = mMaterialGenerator.getMaterial(perm); //We assume that the GBuffer technique contains only one pass. But its true. *newPass = *(templateMat->getTechnique(0)->getPass(0)); fillPass(newPass, originalPass, props); } return gBufferTech; }
void OgreAppLogic::initTracking(int width, int height) { mWebcamBufferL8 = new unsigned char[width*height]; mTrackingSystem->init(width, height); //Create Webcam Material MaterialPtr material = MaterialManager::getSingleton().create("WebcamMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique *technique = material->createTechnique(); technique->createPass(); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); material->getTechnique(0)->getPass(0)->createTextureUnitState(colorTextureName); }
void MaterialEditor::OnNewPass(wxCommandEvent &e) { if(mMaterial.isNull()) return; Ogre::Technique* pTechinque = m_MaterialTree->getSelecteTechnique(); if(pTechinque) { Ogre::Pass* pPass = pTechinque->createPass(); m_Frame->GetEffectObjectProperty()->InitMaterialEditor(mMaterial,mMaterialName); m_MaterialTree->DeleteAllItems(); m_MaterialTree->AddMaterialToTree(mMaterial,mMaterialName); m_MaterialTree->SelectePassItem(pPass); } }
void MeshResourceMarker::onNewMessage(const MarkerConstPtr& old_message, const MarkerConstPtr& new_message) { ROS_ASSERT(new_message->type == visualization_msgs::Marker::MESH_RESOURCE); // flag indicating if the mesh material color needs to be updated bool update_color = false; scene_node_->setVisible(false); if (!entity_ || old_message->mesh_resource != new_message->mesh_resource || old_message->mesh_use_embedded_materials != new_message->mesh_use_embedded_materials) { reset(); if (new_message->mesh_resource.empty()) { return; } if (loadMeshFromResource(new_message->mesh_resource).isNull()) { std::stringstream ss; ss << "Mesh resource marker [" << getStringID() << "] could not load [" << new_message->mesh_resource << "]"; if (owner_) { owner_->setMarkerStatus(getID(), StatusProperty::Error, ss.str()); } ROS_DEBUG("%s", ss.str().c_str()); return; } static uint32_t count = 0; std::stringstream ss; ss << "mesh_resource_marker_" << count++; std::string id = ss.str(); entity_ = context_->getSceneManager()->createEntity(id, new_message->mesh_resource); scene_node_->attachObject(entity_); // create a default material for any sub-entities which don't have their own. ss << "Material"; Ogre::MaterialPtr default_material = Ogre::MaterialManager::getSingleton().create(ss.str(), ROS_PACKAGE_NAME); default_material->setReceiveShadows(false); default_material->getTechnique(0)->setLightingEnabled(true); default_material->getTechnique(0)->setAmbient(0.5, 0.5, 0.5); materials_.insert(default_material); if (new_message->mesh_use_embedded_materials) { // make clones of all embedded materials so selection works correctly S_MaterialPtr materials = getMaterials(); S_MaterialPtr::iterator it; for (it = materials.begin(); it != materials.end(); it++) { if ((*it)->getName() != "BaseWhiteNoLighting") { Ogre::MaterialPtr new_material = (*it)->clone(id + (*it)->getName()); materials_.insert(new_material); } } // make sub-entities use cloned materials for (uint32_t i = 0; i < entity_->getNumSubEntities(); ++i) { std::string mat_name = entity_->getSubEntity(i)->getMaterialName(); if (mat_name != "BaseWhiteNoLighting") { entity_->getSubEntity(i)->setMaterialName(id + mat_name); } else { // BaseWhiteNoLighting is the default material Ogre uses // when it sees a mesh with no material. Here we replace // that with our default_material which gets colored with // new_message->color. entity_->getSubEntity(i)->setMaterial(default_material); } } } else { entity_->setMaterial(default_material); } // add a pass to every material to perform the color tinting S_MaterialPtr::iterator material_it; for (material_it = materials_.begin(); material_it != materials_.end(); material_it++) { Ogre::Technique* technique = (*material_it)->getTechnique(0); color_tint_passes_.push_back(technique->createPass()); } // always update color on resource change update_color = true; handler_.reset(new MarkerSelectionHandler(this, MarkerID(new_message->ns, new_message->id), context_)); handler_->addTrackedObject(entity_); } else { // underlying mesh resource has not changed but if the color has // then we need to update the materials color if (!old_message || old_message->color.r != new_message->color.r || old_message->color.g != new_message->color.g || old_message->color.b != new_message->color.b || old_message->color.a != new_message->color.a) { update_color = true; } } // update material color // if the mesh_use_embedded_materials is true and color is non-zero // then the color will be used to tint the embedded materials if (update_color) { float r = new_message->color.r; float g = new_message->color.g; float b = new_message->color.b; float a = new_message->color.a; Ogre::SceneBlendType blending; bool depth_write; if (a < 0.9998) { blending = Ogre::SBT_TRANSPARENT_ALPHA; depth_write = false; } else { blending = Ogre::SBT_REPLACE; depth_write = true; } for (std::vector<Ogre::Pass*>::iterator it = color_tint_passes_.begin(); it != color_tint_passes_.end(); ++it) { (*it)->setAmbient(0.5 * r, 0.5 * g, 0.5 * b); (*it)->setDiffuse(r, g, b, a); (*it)->setSceneBlending(blending); (*it)->setDepthWriteEnabled(depth_write); (*it)->setLightingEnabled(true); } } Ogre::Vector3 pos, scale; Ogre::Quaternion orient; transform(new_message, pos, orient, scale); scene_node_->setVisible(true); setPosition(pos); setOrientation(orient); scene_node_->setScale(scale); }
Ogre::MaterialPtr MaterialGenerator::create(bool renderCompositeMap, bool displayCompositeMap) { assert(!renderCompositeMap || !displayCompositeMap); static int count = 0; std::stringstream name; name << "terrain/mat" << count++; if (!mShaders) { Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create(name.str(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique* technique = mat->getTechnique(0); technique->removeAllPasses(); if (displayCompositeMap) { Ogre::Pass* pass = technique->createPass(); pass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE); pass->createTextureUnitState(mCompositeMap)->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); } else { assert(mLayerList.size() == mBlendmapList.size()+1); std::vector<Ogre::TexturePtr>::iterator blend = mBlendmapList.begin(); for (std::vector<LayerInfo>::iterator layer = mLayerList.begin(); layer != mLayerList.end(); ++layer) { Ogre::Pass* pass = technique->createPass(); pass->setLightingEnabled(false); pass->setVertexColourTracking(Ogre::TVC_NONE); // TODO: How to handle fog? pass->setFog(true, Ogre::FOG_NONE); bool first = (layer == mLayerList.begin()); Ogre::TextureUnitState* tus; if (!first) { pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA); pass->setDepthFunction(Ogre::CMPF_EQUAL); tus = pass->createTextureUnitState((*blend)->getName()); tus->setAlphaOperation(Ogre::LBX_BLEND_TEXTURE_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE); tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE); tus->setIsAlpha(true); tus->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP); float scale = (16/(16.f+1.f)); tus->setTextureScale(1.f/scale,1.f/scale); } // Add the actual layer texture on top of the alpha map. tus = pass->createTextureUnitState(layer->mDiffuseMap); if (!first) tus->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT); tus->setTextureScale(1/16.f,1/16.f); if (!first) ++blend; } if (!renderCompositeMap) { Ogre::Pass* lightingPass = technique->createPass(); lightingPass->setSceneBlending(Ogre::SBT_MODULATE); lightingPass->setVertexColourTracking(Ogre::TVC_AMBIENT|Ogre::TVC_DIFFUSE); lightingPass->setFog(true, Ogre::FOG_NONE); } } return mat; } #if TERRAIN_USE_SHADER else { sh::MaterialInstance* material = sh::Factory::getInstance().createMaterialInstance (name.str()); material->setProperty ("allow_fixed_function", sh::makeProperty<sh::BooleanValue>(new sh::BooleanValue(false))); if (displayCompositeMap) { sh::MaterialInstancePass* p = material->createPass (); p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex"))); p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment"))); p->mShaderProperties.setProperty ("is_first_pass", sh::makeProperty(new sh::BooleanValue(true))); p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(false))); p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(true))); p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue("0"))); p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue("0"))); p->mShaderProperties.setProperty ("normal_map_enabled", sh::makeProperty (new sh::BooleanValue(false))); p->mShaderProperties.setProperty ("parallax_enabled", sh::makeProperty (new sh::BooleanValue(false))); p->mShaderProperties.setProperty ("normal_maps", sh::makeProperty (new sh::IntValue(0))); sh::MaterialInstanceTextureUnit* tex = p->createTextureUnit ("compositeMap"); tex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mCompositeMap))); tex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp"))); // shadow. TODO: repeated, put in function if (mShadows) { for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i) { sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i)); shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow"))); } } p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue( Ogre::StringConverter::toString(1)))); p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(0))); } else { bool shadows = mShadows && !renderCompositeMap; int layerOffset = 0; while (layerOffset < (int)mLayerList.size()) { int blendmapOffset = (layerOffset == 0) ? 1 : 0; // the first layer of the first pass is the base layer and does not need a blend map // Check how many layers we can fit in this pass int numLayersInThisPass = 0; int numBlendTextures = 0; std::vector<std::string> blendTextures; int remainingTextureUnits = OGRE_MAX_TEXTURE_LAYERS; if (shadows) remainingTextureUnits -= (mSplitShadows ? 3 : 1); while (remainingTextureUnits && layerOffset + numLayersInThisPass < (int)mLayerList.size()) { int layerIndex = numLayersInThisPass + layerOffset; int neededTextureUnits=0; int neededBlendTextures=0; if (layerIndex != 0) { std::string blendTextureName = mBlendmapList[getBlendmapIndexForLayer(layerIndex)]->getName(); if (std::find(blendTextures.begin(), blendTextures.end(), blendTextureName) == blendTextures.end()) { blendTextures.push_back(blendTextureName); ++neededBlendTextures; ++neededTextureUnits; // blend texture } } ++neededTextureUnits; // layer texture // Check if this layer has a normal map if (mNormalMapping && !mLayerList[layerIndex].mNormalMap.empty() && !renderCompositeMap) ++neededTextureUnits; // normal map if (neededTextureUnits <= remainingTextureUnits) { // We can fit another! remainingTextureUnits -= neededTextureUnits; numBlendTextures += neededBlendTextures; ++numLayersInThisPass; } else break; // We're full } sh::MaterialInstancePass* p = material->createPass (); p->setProperty ("vertex_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_vertex"))); p->setProperty ("fragment_program", sh::makeProperty<sh::StringValue>(new sh::StringValue("terrain_fragment"))); if (layerOffset != 0) { p->setProperty ("scene_blend", sh::makeProperty(new sh::StringValue("alpha_blend"))); // Only write if depth is equal to the depth value written by the previous pass. p->setProperty ("depth_func", sh::makeProperty(new sh::StringValue("equal"))); } p->mShaderProperties.setProperty ("render_composite_map", sh::makeProperty(new sh::BooleanValue(renderCompositeMap))); p->mShaderProperties.setProperty ("display_composite_map", sh::makeProperty(new sh::BooleanValue(displayCompositeMap))); p->mShaderProperties.setProperty ("num_layers", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numLayersInThisPass)))); p->mShaderProperties.setProperty ("num_blendmaps", sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(numBlendTextures)))); p->mShaderProperties.setProperty ("normal_map_enabled", sh::makeProperty (new sh::BooleanValue(false))); // blend maps // the index of the first blend map used in this pass int blendmapStart; if (mLayerList.size() == 1) // special case. if there's only one layer, we don't need blend maps at all blendmapStart = 0; else blendmapStart = getBlendmapIndexForLayer(layerOffset+blendmapOffset); for (int i = 0; i < numBlendTextures; ++i) { sh::MaterialInstanceTextureUnit* blendTex = p->createTextureUnit ("blendMap" + Ogre::StringConverter::toString(i)); blendTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(mBlendmapList[blendmapStart+i]->getName()))); blendTex->setProperty ("tex_address_mode", sh::makeProperty (new sh::StringValue("clamp"))); } // layer maps bool anyNormalMaps = false; bool anyParallax = false; size_t normalMaps = 0; for (int i = 0; i < numLayersInThisPass; ++i) { const LayerInfo& layer = mLayerList[layerOffset+i]; // diffuse map sh::MaterialInstanceTextureUnit* diffuseTex = p->createTextureUnit ("diffuseMap" + Ogre::StringConverter::toString(i)); diffuseTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mDiffuseMap))); // normal map (optional) bool useNormalMap = mNormalMapping && !mLayerList[layerOffset+i].mNormalMap.empty() && !renderCompositeMap; bool useParallax = useNormalMap && mParallaxMapping && layer.mParallax; bool useSpecular = layer.mSpecular; if (useNormalMap) { anyNormalMaps = true; anyParallax = anyParallax || useParallax; sh::MaterialInstanceTextureUnit* normalTex = p->createTextureUnit ("normalMap" + Ogre::StringConverter::toString(i)); normalTex->setProperty ("direct_texture", sh::makeProperty (new sh::StringValue(layer.mNormalMap))); } p->mShaderProperties.setProperty ("use_normal_map_" + Ogre::StringConverter::toString(i), sh::makeProperty (new sh::BooleanValue(useNormalMap))); p->mShaderProperties.setProperty ("use_parallax_" + Ogre::StringConverter::toString(i), sh::makeProperty (new sh::BooleanValue(useParallax))); p->mShaderProperties.setProperty ("use_specular_" + Ogre::StringConverter::toString(i), sh::makeProperty (new sh::BooleanValue(useSpecular))); boost::hash_combine(normalMaps, useNormalMap); boost::hash_combine(normalMaps, useNormalMap && layer.mParallax); boost::hash_combine(normalMaps, useSpecular); if (i+layerOffset > 0) { int blendTextureIndex = getBlendmapIndexForLayer(layerOffset+i); std::string blendTextureComponent = getBlendmapComponentForLayer(layerOffset+i); p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i), sh::makeProperty (new sh::StringValue(Ogre::StringConverter::toString(blendTextureIndex-blendmapStart) + "." + blendTextureComponent))); } else { // just to make it shut up about blendmap_component_0 not existing in the first pass. // it might be retrieved, but will never survive the preprocessing step. p->mShaderProperties.setProperty ("blendmap_component_" + Ogre::StringConverter::toString(i), sh::makeProperty (new sh::StringValue(""))); } } p->mShaderProperties.setProperty ("normal_map_enabled", sh::makeProperty (new sh::BooleanValue(anyNormalMaps))); p->mShaderProperties.setProperty ("parallax_enabled", sh::makeProperty (new sh::BooleanValue(anyParallax))); // Since the permutation handler can't handle dynamic property names, // combine normal map settings for all layers into one value p->mShaderProperties.setProperty ("normal_maps", sh::makeProperty (new sh::IntValue(normalMaps))); // shadow if (shadows) { for (int i = 0; i < (mSplitShadows ? 3 : 1); ++i) { sh::MaterialInstanceTextureUnit* shadowTex = p->createTextureUnit ("shadowMap" + Ogre::StringConverter::toString(i)); shadowTex->setProperty ("content_type", sh::makeProperty<sh::StringValue> (new sh::StringValue("shadow"))); } } p->mShaderProperties.setProperty ("shadowtexture_offset", sh::makeProperty (new sh::StringValue( Ogre::StringConverter::toString(numBlendTextures + numLayersInThisPass)))); // Make sure the pass index is fed to the permutation handler, because blendmap components may be different p->mShaderProperties.setProperty ("pass_index", sh::makeProperty(new sh::IntValue(layerOffset))); assert ((int)p->mTexUnits.size() == OGRE_MAX_TEXTURE_LAYERS - remainingTextureUnits); layerOffset += numLayersInThisPass; } } } #endif return Ogre::MaterialManager::getSingleton().getByName(name.str()); }
void MaterialGenerator::generate() { mMaterial = prepareMaterial(mDef->getName()); // reset some attributes resetTexUnitCounter(); // choose textures from list (depending on user iTexSize setting) chooseTextures(); // -------------------------- Main technique ----------------------------- // Ogre::Technique* technique = mMaterial->createTechnique(); // Main pass Ogre::Pass* pass = technique->createPass(); pass->setAmbient( mDef->mProps->ambient.x, mDef->mProps->ambient.y, mDef->mProps->ambient.z ); pass->setDiffuse( mDef->mProps->diffuse.x, mDef->mProps->diffuse.y, mDef->mProps->diffuse.z, 1.0 ); // shader assumes shininess in specular w component pass->setSpecular(mDef->mProps->specular.x, mDef->mProps->specular.y, mDef->mProps->specular.z, mDef->mProps->specular.w); pass->setCullingMode(chooseCullingMode()); pass->setFog(true); // turn off fixed function fog, we use shaders if (!mDef->mProps->lighting) pass->setLightingEnabled(false); if (mDef->mProps->sceneBlend == SBM_ALPHA_BLEND) pass->setSceneBlending(SBT_TRANSPARENT_ALPHA); else if (mDef->mProps->sceneBlend == SBM_COLOUR_BLEND) pass->setSceneBlending(SBT_TRANSPARENT_COLOUR); else if (mDef->mProps->sceneBlend == SBM_ADD) pass->setSceneBlending(SBT_ADD); else if (mDef->mProps->sceneBlend == SBM_MODULATE) pass->setSceneBlending(SBT_MODULATE); pass->setDepthWriteEnabled( mDef->mProps->depthWrite ); pass->setDepthCheckEnabled( mDef->mProps->depthCheck ); pass->setTransparentSortingEnabled( mDef->mProps->transparentSorting ); pass->setAlphaRejectFunction( mDef->mProps->alphaRejectFunc ); pass->setAlphaRejectValue( mDef->mProps->alphaRejectValue ); if (mDef->mProps->depthBias != 0.f) pass->setDepthBias( mDef->mProps->depthBias ); createTexUnits(pass); // create shaders if (!mShaderCached) { try { mVertexProgram = createVertexProgram(); mFragmentProgram = createFragmentProgram(); } catch (Ogre::Exception& e) { LogO(e.getFullDescription()); } //!todo put this code into a function for reusability in other material generators if (mFragmentProgram.isNull() || mVertexProgram.isNull() || !mFragmentProgram->isSupported() || !mVertexProgram->isSupported()) { LogO("[MaterialFactory] WARNING: shader for material '" + mDef->getName() + "' is not supported"); LogO("[MaterialFactory] Vertex program source: "); StringUtil::StrStreamType vSourceStr; generateVertexProgramSource(vSourceStr); LogO(vSourceStr.str()); LogO("[MaterialFactory] Fragment program source: "); StringUtil::StrStreamType fSourceStr; generateFragmentProgramSource(fSourceStr); LogO(fSourceStr.str()); mVertexProgram.setNull(); mFragmentProgram.setNull(); return; } } pass->setVertexProgram(mVertexProgram->getName()); pass->setFragmentProgram(mFragmentProgram->getName()); //set shadow caster technique->setShadowCasterMaterial(chooseShadowCasterMaterial()); if (mShaderCached) { // set individual material shader params individualVertexProgramParams(pass->getVertexProgramParameters()); individualFragmentProgramParams(pass->getFragmentProgramParameters()); } // ----------------------------------------------------------------------- // createSSAOTechnique(); createOccluderTechnique(); // indicate we need enable/disable wind parameter // only needed for trees (wind == 2) because the wind effect has to be disabled before rendering impostors if (mShader->wind == 2) mParent->windMtrs.push_back( mDef->getName() ); if (mDef->mProps->fog) mParent->fogMtrs.push_back( mDef->getName() ); /// uncomment to export to .material //LogO(mDef->getName()); /** //if (mDef->getName() == "Water_cyan") /*{ MaterialSerializer serializer; serializer.exportMaterial(mMaterial, "water.material"); } /**/ /// uncomment to see full shader source code in log /** LogO(mDef->getName()); if (StringUtil::startsWith(mDef->getName(), "FluidWater" )) //"water" //_cyan" { LogO("[MaterialFactory] Vertex program source: "); StringUtil::StrStreamType vSourceStr; generateVertexProgramSource(vSourceStr); LogO(vSourceStr.str()); LogO("[MaterialFactory] Fragment program source: "); StringUtil::StrStreamType fSourceStr; generateFragmentProgramSource(fSourceStr); LogO(fSourceStr.str()); } /**/ }
/**************************************************************************** ** ** Copyright (C) 2014 ** ** This file is generated by the Magus toolkit ** ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." ** ****************************************************************************/ // Include #include "mainwindow.h" #include "Editor_dockwidget.h" #include "constants.h" #include "sme_asset_material.h" #include "sme_node_material.h" #include "sme_asset_technique.h" #include "sme_node_technique.h" #include "sme_asset_pass.h" #include "sme_node_pass.h" #include "sme_asset_texture_unit.h" #include "sme_node_texture_unit.h" //****************************************************************************/ EditorDockWidget::EditorDockWidget(QString title, MainWindow* parent, Qt::WindowFlags flags) : QDockWidget (title, parent, flags), mParent(parent) { mInnerMain = new QMainWindow(); setWidget(mInnerMain); // Perform standard functions createActions(); createMenus(); createToolBars(); // Create the node editor widget. mNodeEditor = new Magus::QtNodeEditor(this); mNodeEditor->setMenuSelectionToCompoundEnabled(false); // Enabling this makes it a bit more complicated mNodeEditor->setMenuExpandCompoundsEnabled(false); // No compounds are used connect(mNodeEditor, SIGNAL(nodeRemoved(QtNode*)), this, SLOT(nodeDeleted())); connect(mNodeEditor, SIGNAL(nodeSelected(QtNode*)), this, SLOT(nodeSelected(QtNode*))); mInnerMain->setCentralWidget(mNodeEditor); mMaterialNode = 0; } //****************************************************************************/ EditorDockWidget::~EditorDockWidget(void) { } //****************************************************************************/ void EditorDockWidget::createActions(void) { mMaterialHToolbarAction = new QAction(QIcon(ICON_MATERIAL), QString("Add a material node to the editor"), this); connect(mMaterialHToolbarAction, SIGNAL(triggered()), this, SLOT(doMaterialHToolbarAction())); mTechniqueHToolbarAction = new QAction(QIcon(ICON_TECHNIQUE), QString("Add a technique node to the editor"), this); connect(mTechniqueHToolbarAction, SIGNAL(triggered()), this, SLOT(doTechniqueHToolbarAction())); mPassHToolbarAction = new QAction(QIcon(ICON_PASS), QString("Add a pass node to the editor"), this); connect(mPassHToolbarAction, SIGNAL(triggered()), this, SLOT(doPassHToolbarAction())); mTextureHToolbarAction = new QAction(QIcon(ICON_TEXTURE), QString("Add a texture unit node to the editor"), this); connect(mTextureHToolbarAction, SIGNAL(triggered()), this, SLOT(doTextureHToolbarAction())); mCogHToolbarAction = new QAction(QIcon(ICON_COG), QString("Generate material"), this); connect(mCogHToolbarAction, SIGNAL(triggered()), this, SLOT(doCogHToolbarAction())); } //****************************************************************************/ void EditorDockWidget::createMenus(void) { } //****************************************************************************/ void EditorDockWidget::createToolBars(void) { mHToolBar = new QToolBar(); mInnerMain->addToolBar(Qt::TopToolBarArea, mHToolBar); mHToolBar->setMinimumHeight(TB_ICON_AND_SPACING); mHToolBar->setMinimumWidth(1200); mHToolBar->addAction(mMaterialHToolbarAction); mHToolBar->addAction(mTechniqueHToolbarAction); mHToolBar->addAction(mPassHToolbarAction); mHToolBar->addAction(mTextureHToolbarAction); mHToolBar->addAction(mCogHToolbarAction); } //****************************************************************************/ void EditorDockWidget::doMaterialHToolbarAction(void) { // Add a material node; only 1 is allowed if (!mMaterialNode) { mMaterialNode = new Magus::QtNodeMaterial(NODE_TITLE_MATERIAL); mNodeEditor->addNode(mMaterialNode); } } //****************************************************************************/ void EditorDockWidget::doTechniqueHToolbarAction(void) { // Add a technique node Magus::QtNodeTechnique* techniqueNode = new Magus::QtNodeTechnique(NODE_TITLE_TECHNIQUE); mNodeEditor->addNode(techniqueNode); } //****************************************************************************/ void EditorDockWidget::doPassHToolbarAction(void) { // Add a pass node Magus::QtNodePass* passNode = new Magus::QtNodePass(NODE_TITLE_PASS); mNodeEditor->addNode(passNode); } //****************************************************************************/ void EditorDockWidget::doTextureHToolbarAction(void) { // Add a texture unit node Magus::QtNodeTextureUnit* textureUnitNode = new Magus::QtNodeTextureUnit(NODE_TITLE_TEXTURE_UNIT); mNodeEditor->addNode(textureUnitNode); } //****************************************************************************/ void EditorDockWidget::doCogHToolbarAction(void) { if (!mMaterialNode) return; if (mMaterialNode->getMaterialName().isEmpty()) return; // ---------------------------------------- Create a material ---------------------------------------- Ogre::LogManager* logManager = Ogre::LogManager::getSingletonPtr(); Ogre::MaterialManager* materialManager = Ogre::MaterialManager::getSingletonPtr(); Ogre::String materialName = mMaterialNode->getMaterialName().toStdString(); // Convert to std format logManager->logMessage("SME: create Ogre material: " + materialName); Ogre::MaterialPtr material = materialManager->create(materialName, "General"); // Remark: Sceneblending is done for each pass individually, although it is defined on material level // ---------------------------------------- Add the technique ---------------------------------------- Magus::QtNode* node = mMaterialNode->getNodeConnectedToPort(PORT_TECHNIQUE_OUT); if (!node) { logManager->logMessage("SME: No technique node available"); return; } Magus::QtNodeTechnique* techniqueNode = static_cast<Magus::QtNodeTechnique*>(node); material->removeAllTechniques(); Ogre::Technique* technique = material->createTechnique(); technique->removeAllPasses(); logManager->logMessage("SME: Technique created" + Ogre::StringConverter::toString(material->getNumTechniques())); // ---------------------------------------- Add the passes ---------------------------------------- Magus::QtNodePass* passNode; Magus::QtNodeTextureUnit* textureUnitNode; Ogre::Pass* pass; Ogre::TextureUnitState* textureUnit; for (unsigned int i = 1; i < 5; ++i) { node = techniqueNode->getNodeConnectedToPort(PORT_PASS_OUT, i); // node with the same name if (node) { passNode = static_cast<Magus::QtNodePass*>(node); pass = technique->createPass(); pass->removeAllTextureUnitStates(); logManager->logMessage("SME: Pass on port nr. " + Ogre::StringConverter::toString(i) + " created"); propagatePassNodeData(passNode, pass); // ---------------------------------------- Add the texture units ---------------------------------------- for (unsigned int j = 1; j < 9; ++j) { node = passNode->getNodeConnectedToPort(PORT_TEXTURE_OUT, j); if (node) { logManager->logMessage("SME: Texture unit on port nr. " + Ogre::StringConverter::toString(j) + " of Pass port nr. " + Ogre::StringConverter::toString(i) + " created"); textureUnitNode = static_cast<Magus::QtNodeTextureUnit*>(node); textureUnit = pass->createTextureUnitState(); propagateTextureUnitNodeData(textureUnitNode, textureUnit); } } } } // Assign the material to the ogrehead material->compile(); material->load(); mParent->getOgreManager()->getOgreWidget(1)->mEntity->setMaterial(material); }
void GActiveMarker::markerCallback(const visualization_msgs::Marker& marker) { int frameNo; bool found, renew; string name; GActiveMarker * tAM; vector<Gadget *>::iterator gadIt; switch (marker.action) { case visualization_msgs::Marker::DELETE: { // Make an appropriate name based on the namespace and marker ID name = marker.ns + boost::lexical_cast<std::string>(marker.id); found = false; for (gadIt = boss->gadgets.begin(); gadIt != boss->gadgets.end(); gadIt++) { if ((*gadIt)->name == name) { found = true; break; } } // No marker, leave without a sound if (!found) { break; } (*gadIt)->killMe = true; break; } // ROS has ADD and MODIFY have the same value... case visualization_msgs::Marker::ADD: //case visualization_msgs::Marker::MODIFY: // Make an appropriate name based on the namespace and marker ID name = marker.ns + boost::lexical_cast<std::string>(marker.id); // Get the associated frame frameNo = Frame::findFrame(marker.header.frame_id); // If we can't find the frame, or it is invalid leave if (frameNo < 0) { return; } if (!availableFrames[frameNo].valid) { return; } // Look for an existing Gadget with this name found = false; for (gadIt = boss->gadgets.begin(); gadIt != boss->gadgets.end(); gadIt++) { if ((*gadIt)->name == name) { found = true; break; } } if (found) { // We're modifying an existing marker tAM = (GActiveMarker * )*gadIt; } else // !found { // Create a new marker tAM = new GActiveMarker(name); // Create the gadget for this marker boss->addGadget(tAM); // Have the active marker create a scene node (graphicNode) tAM->show(true); } // Set the Gadget's frame tAM->sourceFrame = frameNo; // If the marker's nature changes, free up all its allocated graphic memory if (found) { if (tAM->markerType != marker.type) { tAM->cleanup(); renew = true; tAM->markerType = marker.type; } else { renew = false; } } else { renew = true; tAM->markerType = marker.type; } switch (marker.type) { case visualization_msgs::Marker::ARROW: { if (renew) { Shape * shape; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } shape = new Shape(Shape::Cone, tAM->scene, tAM->subGraphicNode); tAM->shapes.push_back(shape); shape = new Shape(Shape::RoughCylinder, tAM->scene, tAM->subGraphicNode); tAM->shapes.push_back(shape); } Ogre::Vector3 startPoint; Ogre::Vector3 endPoint; if (marker.points.size() > 1) { startPoint[0] = marker.points[0].x; startPoint[1] = marker.points[0].y, startPoint[2] = marker.points[0].z; endPoint[0] = marker.points[1].x; endPoint[1] = marker.points[1].y; endPoint[2] = marker.points[1].z; } else { if (marker.points.size() == 1) { tAM->publishStatus(Gadget::WARNING, "To few points to specify an arrow direction, 2 needed"); } startPoint[0] = 0; startPoint[1] = 0, startPoint[2] = 0; endPoint[0] = 1; endPoint[1] = 0; endPoint[2] = 0; } tAM->shapes[0]->alignToLineSegment(startPoint + (endPoint - startPoint) * 0.9, endPoint, 1); tAM->shapes[0]->setScale(Ogre::Vector3(marker.scale.y, marker.scale.x * 0.2, marker.scale.y)); tAM->shapes[1]->alignToLineSegment(startPoint, endPoint, 1); tAM->shapes[1]->setScale(Ogre::Vector3(marker.scale.y * 0.1, marker.scale.x * 0.8, marker.scale.y * 0.1)); // Set shape properties tAM->shapes[0]->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added arrow marker"); } break; } case visualization_msgs::Marker::CUBE: case visualization_msgs::Marker::SPHERE: case visualization_msgs::Marker::CYLINDER: { if (renew) { Shape * shape; switch (marker.type) { case visualization_msgs::Marker::CUBE: shape = new Shape(Shape::Cube, tAM->scene, tAM->graphicNode); break; case visualization_msgs::Marker::SPHERE: shape = new Shape(Shape::Sphere, tAM->scene, tAM->graphicNode); break; case visualization_msgs::Marker::CYLINDER: shape = new Shape(Shape::Cylinder, tAM->scene, tAM->graphicNode); break; } tAM->shapes.push_back(shape); } // Set shape properties tAM->shapes[0]->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->shapes[0]->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); tAM->shapes[0]->setScale(Ogre::Vector3(marker.scale.x, marker.scale.y, marker.scale.z)); tAM->shapes[0]->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); if (renew) { switch (marker.type) { case visualization_msgs::Marker::CUBE: tAM->publishStatus(Gadget::OKAY, "Successfully added cube marker"); break; case visualization_msgs::Marker::SPHERE: tAM->publishStatus(Gadget::OKAY, "Successfully added sphere marker"); break; case visualization_msgs::Marker::CYLINDER: tAM->publishStatus(Gadget::OKAY, "Successfully added cylinder marker"); break; } } break; } case visualization_msgs::Marker::LINE_STRIP: { unsigned int N; unsigned int i; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } // Line count N = marker.points.size() - 1; if (N < 1) { tAM->publishStatus(Gadget::ERROR, "Insufficient data to draw lines"); return; } // If the number of preallocated shapes is too many, cull a few if (!renew && tAM->shapes.size() > N) { while (tAM->shapes.size() > N) { delete tAM->shapes[0]; tAM->shapes.erase(tAM->shapes.begin()); } } // Otherwise, if we have too few shapes preallocated, add a few if (tAM->shapes.size() < N) { while (tAM->shapes.size() < N) { Shape * shape = new Shape(Shape::RoughCylinder, tAM->scene, tAM->subGraphicNode); tAM->shapes.push_back(shape); } } // Set shapes' properties for (i = 0; i < N; i++) { tAM->shapes[i]->alignToLineSegment(Ogre::Vector3(marker.points[i].x, marker.points[i].y, marker.points[i].z), Ogre::Vector3(marker.points[i + 1].x, marker.points[i + 1].y, marker.points[i + 1].z), marker.scale.x); } // Set the shapes colors based on whether we're getting a list of colors // or just a single color... if (marker.colors.size() != marker.points.size()) { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); } } else { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.colors[i].r, marker.colors[i].g, marker.colors[i].b, marker.colors[i].a)); } } tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added line strip marker"); } break; } case visualization_msgs::Marker::LINE_LIST: { unsigned int N; unsigned int i; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } if (marker.points.size() % 2 != 0) { tAM->publishStatus(Gadget::ERROR, "Need 2xN points to draw N lines"); return; } // Line count N = marker.points.size() / 2; // If the number of preallocated shapes is too many, cull a few if (!renew && tAM->shapes.size() > N) { while (tAM->shapes.size() > N) { delete tAM->shapes[0]; tAM->shapes.erase(tAM->shapes.begin()); } } // Otherwise, if we have too few shapes preallocated, add a few if (tAM->shapes.size() < N) { while (tAM->shapes.size() < N) { Shape * shape = new Shape(Shape::RoughCylinder, tAM->scene, tAM->subGraphicNode); tAM->shapes.push_back(shape); } } // Set shapes' properties for (i = 0; i < N; i++) { tAM->shapes[i]->alignToLineSegment(Ogre::Vector3(marker.points[i * 2].x, marker.points[i * 2].y, marker.points[i * 2].z), Ogre::Vector3(marker.points[i * 2 + 1].x, marker.points[i * 2 + 1].y, marker.points[i * 2 + 1].z), marker.scale.x); } // Set the shapes colors based on whether we're getting a list of colors // or just a single color... if (marker.colors.size() != marker.points.size()) { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); } } else { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.colors[i * 2].r, marker.colors[i * 2].g, marker.colors[i * 2].b, marker.colors[i * 2].a)); } } tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added line list marker"); } break; } case visualization_msgs::Marker::SPHERE_LIST: case visualization_msgs::Marker::CUBE_LIST: { int shapeType; unsigned int i; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } switch (marker.type) { case visualization_msgs::Marker::SPHERE_LIST: shapeType = Shape::Sphere; break; case visualization_msgs::Marker::CUBE_LIST: shapeType = Shape::Cube; break; } // If the number of preallocated shapes is too many, cull a few if (!renew && tAM->shapes.size() > marker.points.size()) { while (tAM->shapes.size() > marker.points.size()) { delete tAM->shapes[0]; tAM->shapes.erase(tAM->shapes.begin()); } } // Otherwise, if we have too few shapes preallocated, add a few if (tAM->shapes.size() < marker.points.size()) { while (tAM->shapes.size() < marker.points.size()) { Shape * shape = new Shape(shapeType, tAM->scene, tAM->subGraphicNode); tAM->shapes.push_back(shape); } } // Set shapes' properties for (i = 0; i < marker.points.size(); i++) { tAM->shapes[i]->setPosition(Ogre::Vector3(marker.points[i].x, marker.points[i].y, marker.points[i].z)); tAM->shapes[i]->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); tAM->shapes[i]->setScale(Ogre::Vector3(marker.scale.x, marker.scale.y, marker.scale.z)); } // Set the shapes colors based on whether we're getting a list of colors // or just a single color... if (marker.colors.size() != marker.points.size()) { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); } } else { for (i = 0; i < tAM->shapes.size(); i++) { tAM->shapes[i]->setColor(Ogre::ColourValue(marker.colors[i].r, marker.colors[i].g, marker.colors[i].b, marker.colors[i].a)); } } tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); if (renew) { switch (marker.type) { case visualization_msgs::Marker::CUBE_LIST: tAM->publishStatus(Gadget::OKAY, "Successfully added cube list marker"); break; case visualization_msgs::Marker::SPHERE_LIST: tAM->publishStatus(Gadget::OKAY, "Successfully added sphere list marker"); break; } } } break; case visualization_msgs::Marker::POINTS: { unsigned int i; unsigned int N; if (renew) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); if (marker.points.size() > 0) { string materialName = name + "PointMat"; tAM->material = Ogre::MaterialManager::getSingleton().create(materialName.c_str(), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); tAM->material->setPointSize(marker.scale.x); Ogre::Technique* pT = tAM->material->getTechnique( 0 ); if( NULL == pT ) pT = tAM->material->createTechnique(); Ogre::Pass* pP = pT->getPass( 0 ); if( NULL == pP ) pP = pT->createPass(); // set parameters pP->setVertexColourTracking(Ogre::TVC_AMBIENT); pP->setLightingEnabled(false); //pP->setDepthCheckEnabled(true); //pP->setDepthWriteEnabled(false); //pP->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA); tAM->manual = tAM->scene->createManualObject(tAM->name + "_manual"); tAM->subGraphicNode->attachObject(tAM->manual); tAM->manual->setDynamic(true); tAM->manual->estimateVertexCount(1000); tAM->manual->begin(materialName.c_str(), Ogre::RenderOperation::OT_POINT_LIST); } else { tAM->publishStatus(Gadget::WARNING, "No data in message"); } } else { if (marker.points.size() > 0) { tAM->material->setPointSize(marker.scale.x); tAM->manual->beginUpdate(0); } else { tAM->publishStatus(Gadget::WARNING, "No data in message"); } } N = marker.points.size(); // Setting each point's color independently or not? if (marker.colors.size() == marker.points.size()) { for (i = 0; i < N; i++) { tAM->manual->position(marker.points[i].x, marker.points[i].y, marker.points[i].z); tAM->manual->colour(Ogre::ColourValue(marker.colors[i].r, marker.colors[i].g, marker.colors[i].b, marker.colors[i].a)); } } else { tAM->manual->colour(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); for (i = 0; i < N; i++) { tAM->manual->position(marker.points[i].x, marker.points[i].y, marker.points[i].z); } } tAM->manual->end(); //tAM->subGraphicNode->setScale(Ogre::Vector3(marker.scale.x, marker.scale.y, // marker.scale.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); } if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added points marker"); } break; case visualization_msgs::Marker::TEXT_VIEW_FACING: { // If we must abandon all of our preallocated data if (renew) { tAM->text = new Ogre::MovableText("TextLabel" + boost::lexical_cast<std::string>(textNameNum), marker.text); // Create host scene nodes tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); tAM->subGraphicNode->attachObject(tAM->text); } // Update movable text properties tAM->text->setCaption(marker.text); tAM->text->setColor(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); tAM->text->setCharacterHeight(marker.scale.z); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added view facing text marker"); } break; } case visualization_msgs::Marker::TRIANGLE_LIST: { unsigned int i; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } // Make sure we 3xN points to make triangles if (marker.points.size() % 3 == 0) { if (marker.points.size() > 0) { if (renew) { tAM->manual = tAM->scene->createManualObject(name + "_manual"); tAM->subGraphicNode->attachObject(tAM->manual); tAM->manual->setDynamic(true); tAM->manual->estimateVertexCount(1000); tAM->manual->begin("Surfaces/FlatVertexColour", Ogre::RenderOperation::OT_TRIANGLE_LIST); } else { tAM->manual->beginUpdate(0); } } else { tAM->publishStatus(Gadget::WARNING, "No point data"); return; } } else { tAM->publishStatus(Gadget::ERROR, "Need 3xN points to draw N triangles"); return; } // Handle the cases of colors being populated correctly and not, separately if (marker.colors.size() == marker.points.size()) { for (i = 0; i < marker.points.size(); i++) { tAM->manual->position(marker.points[i].x, marker.points[i].y, marker.points[i].z); tAM->manual->colour(Ogre::ColourValue(marker.colors[i].r, marker.colors[i].g, marker.colors[i].b, marker.colors[i].a)); } } else { tAM->manual->colour(Ogre::ColourValue(marker.color.r, marker.color.g, marker.color.b, marker.color.a)); for (i = 0; i < marker.points.size(); i++) { tAM->manual->position(marker.points[i].x, marker.points[i].y, marker.points[i].z); } } tAM->manual->end(); tAM->subGraphicNode->setScale(Ogre::Vector3(marker.scale.x, marker.scale.y, marker.scale.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added triangle list marker"); } break; } case visualization_msgs::Marker::MESH_RESOURCE: // If something has changed free up old resources if (!renew && (tAM->meshResource != marker.mesh_resource)) { if (tAM->entity) { // TODO!! : Need to destroy scene nodes tAM->scene->destroyEntity(tAM->entity); tAM->entity = NULL; } renew = true; } if (renew) { // Load the mesh int gotMaterial; tAM->mesh = loadMesh(marker.mesh_resource, gotMaterial); if (tAM->mesh.isNull()) { tAM->publishStatus(Gadget::ERROR, "Failed to load mesh " + marker.mesh_resource); return; } // Create Ogre entity to encapsulate it tAM->entity = tAM->scene->createEntity((name + "_Ent").c_str(), marker.mesh_resource); if (!gotMaterial) { Ogre::MaterialPtr templateMat = Ogre::MaterialManager::getSingleton().getByName("Template/WhiteNoBlend"); tAM->entity->setMaterial(templateMat); tAM->publishStatus(Gadget::WARNING, "No material associated with mesh " + marker.mesh_resource); } tAM->meshResource = marker.mesh_resource; if (!tAM->subGraphicNode) { tAM->subGraphicNode = tAM->graphicNode->createChildSceneNode(); } tAM->subGraphicNode->attachObject(tAM->entity); } // Update scale and position of the mesh tAM->subGraphicNode->setScale(Ogre::Vector3(marker.scale.x, marker.scale.y, marker.scale.z)); tAM->subGraphicNode->setOrientation(Ogre::Quaternion(marker.pose.orientation.w, marker.pose.orientation.x, marker.pose.orientation.y, marker.pose.orientation.z)); tAM->subGraphicNode->setPosition(Ogre::Vector3(marker.pose.position.x, marker.pose.position.y, marker.pose.position.z)); // Update to ensure the graphic is placed at the correct location tAM->update(); if (renew) { tAM->publishStatus(Gadget::OKAY, "Successfully added mesh marker"); } break; } if (tAM->boundsVisible) { tAM->calculateBounds(); tAM->boundsChanged = true; } break; } }
int initOgreAR(aruco::CameraParameters camParams, unsigned char* buffer, std::string resourcePath) { /// INIT OGRE FUNCTIONS #ifdef _WIN32 root = new Ogre::Root(resourcePath + "plugins_win.cfg", resourcePath + "ogre_win.cfg"); #elif __x86_64__ || __ppc64__ root = new Ogre::Root(resourcePath + "plugins_x64.cfg", resourcePath + "ogre.cfg"); #else root = new Ogre::Root(resourcePath + "plugins.cfg", resourcePath + "ogre.cfg"); #endif if (!root->showConfigDialog()) return -1; Ogre::SceneManager* smgr = root->createSceneManager(Ogre::ST_GENERIC); /// CREATE WINDOW, CAMERA AND VIEWPORT Ogre::RenderWindow* window = root->initialise(true); Ogre::Camera *camera; Ogre::SceneNode* cameraNode; camera = smgr->createCamera("camera"); camera->setNearClipDistance(0.01f); camera->setFarClipDistance(10.0f); camera->setProjectionType(Ogre::PT_ORTHOGRAPHIC); camera->setPosition(0, 0, 0); camera->lookAt(0, 0, 1); double pMatrix[16]; camParams.OgreGetProjectionMatrix(camParams.CamSize,camParams.CamSize, pMatrix, 0.05,10, false); Ogre::Matrix4 PM(pMatrix[0], pMatrix[1], pMatrix[2] , pMatrix[3], pMatrix[4], pMatrix[5], pMatrix[6] , pMatrix[7], pMatrix[8], pMatrix[9], pMatrix[10], pMatrix[11], pMatrix[12], pMatrix[13], pMatrix[14], pMatrix[15]); camera->setCustomProjectionMatrix(true, PM); camera->setCustomViewMatrix(true, Ogre::Matrix4::IDENTITY); window->addViewport(camera); cameraNode = smgr->getRootSceneNode()->createChildSceneNode("cameraNode"); cameraNode->attachObject(camera); /// CREATE BACKGROUND FROM CAMERA IMAGE int width = camParams.CamSize.width; int height = camParams.CamSize.height; // create background camera image mPixelBox = Ogre::PixelBox(width, height, 1, Ogre::PF_R8G8B8, buffer); // Create Texture mTexture = Ogre::TextureManager::getSingleton().createManual("CameraTexture",Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D,width,height,0,Ogre::PF_R8G8B8,Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); //Create Camera Material Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create("CameraMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique *technique = material->createTechnique(); technique->createPass(); material->getTechnique(0)->getPass(0)->setLightingEnabled(false); material->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); material->getTechnique(0)->getPass(0)->createTextureUnitState("CameraTexture"); Ogre::Rectangle2D* rect = new Ogre::Rectangle2D(true); rect->setCorners(-1.0, 1.0, 1.0, -1.0); rect->setMaterial("CameraMaterial"); // Render the background before everything else rect->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND); // Hacky, but we need to set the bounding box to something big, use infinite AAB to always stay visible Ogre::AxisAlignedBox aabInf; aabInf.setInfinite(); rect->setBoundingBox(aabInf); // Attach background to the scene Ogre::SceneNode* node = smgr->getRootSceneNode()->createChildSceneNode("Background"); node->attachObject(rect); /// CREATE SIMPLE OGRE SCENE // add sinbad.mesh Ogre::ResourceGroupManager::getSingleton().addResourceLocation(resourcePath + "Sinbad.zip", "Zip", "Popular"); Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); for(int i=0; i<MAX_MARKERS; i++) { Ogre::String entityName = "Marker_" + Ogre::StringConverter::toString(i); Ogre::Entity* ogreEntity = smgr->createEntity(entityName, "Sinbad.mesh"); Ogre::Real offset = ogreEntity->getBoundingBox().getHalfSize().y; ogreNode[i] = smgr->getRootSceneNode()->createChildSceneNode(); // add entity to a child node to correct position (this way, entity axis is on feet of sinbad) Ogre::SceneNode *ogreNodeChild = ogreNode[i]->createChildSceneNode(); ogreNodeChild->attachObject(ogreEntity); // Sinbad is placed along Y axis, we need to rotate to put it along Z axis so it stands up over the marker // first rotate along X axis, then add offset in Z dir so it is over the marker and not in the middle of it ogreNodeChild->rotate(Ogre::Vector3(1,0,0), Ogre::Radian(Ogre::Degree(90))); ogreNodeChild->translate(0,0,offset,Ogre::Node::TS_PARENT); // mesh is too big, rescale! const float scale = 0.006675f; ogreNode[i]->setScale(scale, scale, scale); // Init animation ogreEntity->getSkeleton()->setBlendMode(Ogre::ANIMBLEND_CUMULATIVE); if(i==0) { baseAnim[i] = ogreEntity->getAnimationState("HandsClosed"); topAnim[i] = ogreEntity->getAnimationState("HandsRelaxed"); } else if(i==1) { baseAnim[i] = ogreEntity->getAnimationState("Dance"); topAnim[i] = ogreEntity->getAnimationState("Dance"); } else if(i==2) { baseAnim[i] = ogreEntity->getAnimationState("RunBase"); topAnim[i] = ogreEntity->getAnimationState("RunTop"); } else { baseAnim[i] = ogreEntity->getAnimationState("IdleBase"); topAnim[i] = ogreEntity->getAnimationState("IdleTop"); } baseAnim[i]->setLoop(true); topAnim[i]->setLoop(true); baseAnim[i]->setEnabled(true); topAnim[i]->setEnabled(true); } /// KEYBOARD INPUT READING size_t windowHnd = 0; window->getCustomAttribute("WINDOW", &windowHnd); im = OIS::InputManager::createInputSystem(windowHnd); keyboard = static_cast<OIS::Keyboard*>(im->createInputObject(OIS::OISKeyboard, true)); return 1; }
Camera::Camera(Event::Lane& lane, GameHandle cameraHandle, Ogre::SceneNode* camNode, Ogre::RenderTarget* renderTarget, u32 width, u32 height, const v3& position, const qv4& orientation, GameHandle parent) : mSubLane(lane.createSubLane()), mCameraNode(camNode), mRenderTarget(renderTarget), mHandle(cameraHandle), mNodeCreated(false), mRenderTargetCreated(false) { Ogre::SceneManager* sceneMgr = Ogre::Root::getSingleton().getSceneManager(BFG_SCENEMANAGER); if (mCameraNode == NULL) // Create SceneNode { if (sceneMgr->hasSceneNode(stringify(mHandle))) { mCameraNode = sceneMgr->getSceneNode(stringify(mHandle)); } else { mCameraNode = sceneMgr->getRootSceneNode()->createChildSceneNode(stringify(mHandle)); mNodeCreated = true; } } mCameraNode->setOrientation(toOgre(orientation)); mCameraNode->setPosition(toOgre(position)); v3 target = toBFG(mCameraNode->getOrientation().zAxis()); norm(target); Ogre::Camera* cam; cam = sceneMgr->createCamera(stringify(mHandle)); cam->setFOVy(Ogre::Degree(60.0f)); cam->setNearClipDistance(0.1f); cam->setFarClipDistance(250000.0f); cam->lookAt(toOgre(target)*10); mCameraNode->attachObject(cam); infolog << "Camera: " << stringify(mHandle) << " created."; if (mRenderTarget == NULL) { // Create renderToTexture RenderTarget if (width == 0 || height == 0) { throw std::logic_error("Too few information to create a render target."); } cam->setAspectRatio((f32)width / (f32)height); Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual ( stringify(mHandle), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, width, height, 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET ); mRenderTarget = texture->getBuffer()->getRenderTarget(); prepareRenderTarget(); mRenderTarget->addViewport(cam); mRenderTarget->getViewport(0)->setClearEveryFrame(true); mRenderTarget->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black); mRenderTarget->getViewport(0)->setOverlaysEnabled(false); Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().getByName(stringify(mHandle)); if (mat.isNull()) { mat = Ogre::MaterialManager::getSingleton().create( stringify(mHandle), Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); } Ogre::Technique* tech = mat->getTechnique(0); if (!tech) { tech = mat->createTechnique(); } Ogre::Pass* pass = tech->getPass(0); if (!pass) { pass = tech->createPass(); } pass->setLightingEnabled(false); if (pass->getNumTextureUnitStates() > 0) { Ogre::TextureUnitState* txState = NULL; txState = pass->getTextureUnitState(0); txState->setTextureName(stringify(mHandle)); } else { pass->createTextureUnitState(stringify(mHandle)); } mRenderTarget->setAutoUpdated(true); mRenderTargetCreated = true; infolog << "Rendertarget: " << stringify(mHandle) << " created."; } else { prepareRenderTarget(); f32 width = static_cast<f32>(mRenderTarget->getWidth()); f32 height = static_cast<f32>(mRenderTarget->getHeight()); cam->setAspectRatio(width / height); mRenderTarget->addViewport(cam); } // mSubLane->connect(ID::VE_UPDATE_POSITION, this, &Camera::updatePosition, mHandle); // mSubLane->connect(ID::VE_UPDATE_ORIENTATION, this, &Camera::updateOrientation, mHandle); mSubLane->connect(ID::VE_SET_CAMERA_TARGET, this, &Camera::onSetTarget, mHandle); if (parent != NULL_HANDLE) { onSetTarget(parent); } }
void ParticleMaterialGenerator::generate() { mMaterial = prepareMaterial(mDef->getName()); // reset some attributes resetTexUnitCounter(); // choose textures from list (depending on user iTexSize setting) chooseTextures(); // -------------------------- Main technique ----------------------------- // Ogre::Technique* technique = mMaterial->createTechnique(); // particledepth pass Ogre::Pass* particleDepthPass = technique->createPass(); particleDepthPass->setAmbient( mDef->mProps->ambient.x, mDef->mProps->ambient.y, mDef->mProps->ambient.z ); particleDepthPass->setDiffuse( mDef->mProps->diffuse.x, mDef->mProps->diffuse.y, mDef->mProps->diffuse.z, 1.0 ); particleDepthPass->setSpecular(mDef->mProps->specular.x, mDef->mProps->specular.y, mDef->mProps->specular.z, mDef->mProps->specular.w); particleDepthPass->setFog(true); // actually this disables fog if (!mDef->mProps->lighting) particleDepthPass->setLightingEnabled(false); if (mDef->mProps->sceneBlend == SBM_ALPHA_BLEND) particleDepthPass->setSceneBlending(SBT_TRANSPARENT_ALPHA); else if (mDef->mProps->sceneBlend == SBM_COLOUR_BLEND) particleDepthPass->setSceneBlending(SBT_TRANSPARENT_COLOUR); else if (mDef->mProps->sceneBlend == SBM_ADD) particleDepthPass->setSceneBlending(SBT_ADD); else if (mDef->mProps->sceneBlend == SBM_MODULATE) particleDepthPass->setSceneBlending(SBT_MODULATE); particleDepthPass->setDepthWriteEnabled( mDef->mProps->depthWrite ); particleDepthPass->setDepthCheckEnabled( mDef->mProps->depthCheck ); particleDepthPass->setTransparentSortingEnabled( mDef->mProps->transparentSorting ); particleDepthPass->setAlphaRejectFunction( mDef->mProps->alphaRejectFunc ); particleDepthPass->setAlphaRejectValue( mDef->mProps->alphaRejectValue ); Ogre::TextureUnitState* tu = particleDepthPass->createTextureUnitState( mDiffuseMap ); tu->setName("diffuseMap"); tu->setTextureAddressingMode(mDef->mProps->textureAddressMode); tu = particleDepthPass->createTextureUnitState(); tu->setName("depthMap"); tu->setTextureAddressingMode(mDef->mProps->textureAddressMode); // create shaders HighLevelGpuProgramPtr fragmentProg, vertexProg; try { vertexProg = createSoftParticleVertexProgram(); fragmentProg = createSoftParticleFragmentProgram(); } catch (Ogre::Exception& e) { LogO(e.getFullDescription()); } if (fragmentProg.isNull() || vertexProg.isNull() || !fragmentProg->isSupported() || !vertexProg->isSupported()) { LogO("[MaterialFactory] WARNING: ambient shader for material '" + mDef->getName() + "' is not supported."); } else { particleDepthPass->setVertexProgram(vertexProg->getName()); particleDepthPass->setFragmentProgram(fragmentProg->getName()); } createSSAOTechnique(); createOccluderTechnique(); // indicate we need depth buffer set every frame mParent->softMtrs.push_back(mDef->getName()); }
void WaterMaterialGenerator::generate() { mMaterial = prepareMaterial(mDef->getName()); resetTexUnitCounter(); // we need a lot of uniform constants, disabling shadows reduces them significantly so that it can still run on PS2 const RenderSystemCapabilities *caps = Root::getSingleton().getRenderSystem()->getCapabilities(); if(!caps->isShaderProfileSupported("ps_4_0") && !caps->isShaderProfileSupported("fp40")) mDef->mProps->receivesShadows = false; // -------------------------- Main technique ----------------------------- // Ogre::Technique* technique = mMaterial->createTechnique(); // Main pass ----------------------------------------------------------- Ogre::Pass* pass = technique->createPass(); pass->setCullingMode(CULL_NONE); pass->setDepthWriteEnabled(true); if (!mParent->getRefract()) pass->setSceneBlending(SBT_TRANSPARENT_ALPHA); Ogre::TextureUnitState* tu; // normal map mNormalMap = pickTexture(&mDef->mProps->normalMaps); tu = pass->createTextureUnitState( mNormalMap ); tu->setName("normalMap"); mNormalTexUnit = mTexUnit_i; mTexUnit_i++; // global terrain lightmap (static) if (needTerrainLightMap()) { tu = pass->createTextureUnitState(""); // texture name set later (in changeShadows) tu->setName("terrainLightMap"); mTerrainLightTexUnit = mTexUnit_i; mTexUnit_i++; } if (mParent->getRefract()) { tu = pass->createTextureUnitState( "PlaneRefraction" ); tu->setName("refractionMap"); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); mScreenRefrUnit = mTexUnit_i++; } if (mParent->getReflect()) { tu = pass->createTextureUnitState( "PlaneReflection" ); tu->setName("reflectionMap"); tu->setTextureAddressingMode(TextureUnitState::TAM_CLAMP); mScreenReflUnit = mTexUnit_i++; } //else { // retrieve sky texture name from scene std::string skyTexName; if (mParent->pApp->terrain) { MaterialPtr mtrSky = MaterialManager::getSingleton().getByName(mParent->pApp->sc.skyMtr); if(!mtrSky.isNull()) { Pass* passSky = mtrSky->getTechnique(0)->getPass(0); TextureUnitState* tusSky = passSky->getTextureUnitState(0); skyTexName = tusSky->getTextureName(); } } else skyTexName = String("white.png"); tu = pass->createTextureUnitState( skyTexName ); tu->setName("skyMap"); tu->setTextureAddressingMode(TextureUnitState::TAM_MIRROR); mEnvTexUnit = mTexUnit_i++; } // waterDepth tu = pass->createTextureUnitState( "waterDepth.png" ); tu->setName("depthMap"); tu->setTextureAddressingMode(TextureUnitState::TAM_BORDER); tu->setTextureBorderColour(ColourValue::White); // outside tex water always visible mWaterDepthUnit = mTexUnit_i; mTexUnit_i++; // realtime shadow maps if (needShadows()) { mShadowTexUnit_start = mTexUnit_i; for (int i = 0; i < mParent->getNumShadowTex(); ++i) { tu = pass->createTextureUnitState(); tu->setName("shadowMap" + toStr(i)); tu->setContentType(TextureUnitState::CONTENT_SHADOW); tu->setTextureAddressingMode(TextureUnitState::TAM_BORDER); tu->setTextureBorderColour(ColourValue::White); mTexUnit_i++; } } // shader if (!mShaderCached) { mVertexProgram = createVertexProgram(); mFragmentProgram = createFragmentProgram(); } pass->setVertexProgram(mVertexProgram->getName()); pass->setFragmentProgram(mFragmentProgram->getName()); if (mShaderCached) { individualFragmentProgramParams(pass->getFragmentProgramParameters()); individualVertexProgramParams(pass->getFragmentProgramParameters()); } // ----------------------------------------------------------------------- // createSSAOTechnique(); createOccluderTechnique(); // indicate we need 'time' parameter set every frame mParent->timeMtrs.push_back(mDef->getName()); /* if (mDef->getName() == "Grease_jelly") { LogO("[MaterialFactory] Vertex program source: "); StringUtil::StrStreamType vSourceStr; generateVertexProgramSource(vSourceStr); LogO(vSourceStr.str()); LogO("[MaterialFactory] Fragment program source: "); StringUtil::StrStreamType fSourceStr; generateFragmentProgramSource(fSourceStr); LogO(fSourceStr.str()); } /**/ }
void Game::setupScene() { // Init stuff for render to texture - Minimap // First the texture rtt_texture_minimap = Ogre::TextureManager::getSingleton().createManual("RttTex", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, OgreFW::getSingletonPtr()->m_pRenderWnd->getWidth(), OgreFW::getSingletonPtr()->m_pRenderWnd->getHeight(), 0, Ogre::PF_R8G8B8, Ogre::TU_RENDERTARGET); // Then, get its render target renderTextureTarget = rtt_texture_minimap->getBuffer()->getRenderTarget(); renderTextureTarget->addViewport(OgreFW::getSingletonPtr()->m_pCamera); renderTextureTarget->getViewport(0)->setClearEveryFrame(true); renderTextureTarget->getViewport(0)->setBackgroundColour(Ogre::ColourValue::Black); renderTextureTarget->getViewport(0)->setOverlaysEnabled(false); // Set it active! renderTextureTarget->setActive(true); // Last, the mini rectangle mMiniScreen = new Ogre::Rectangle2D(true); mMiniScreen->setCorners(0.75f, -0.75f, 1.0f, -1.0f); mMiniScreen->setBoundingBox(Ogre::AxisAlignedBox(-100000.0f * Ogre::Vector3::UNIT_SCALE, 100000.0f * Ogre::Vector3::UNIT_SCALE)); // Scenenode, then add mMiniScreenSN = OgreFW::getSingletonPtr()->m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode"); mMiniScreenSN->attachObject(mMiniScreen); // The texture needs its material Ogre::MaterialPtr renderMaterial = Ogre::MaterialManager::getSingleton().create("RttMat", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); Ogre::Technique* matTechnique = renderMaterial->createTechnique(); matTechnique->createPass(); renderMaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false); renderMaterial->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex"); mMiniScreen->setMaterial("RttMat"); //Register this as a listener renderTextureTarget->addListener(this); // Init the CollisionHandler GameCollisionHandler = new CollisionHandler(OgreFW::getSingletonPtr()->m_pSceneMgr); // Init the first level myLevel = myLevelFactory->create(); // Pass the LevelObjects to the collision_handler std::vector<LevelBlock*> levobjs = myLevel->getLevelObjects(); for (std::vector<LevelBlock*>::iterator i = levobjs.begin(); i != levobjs.end(); ++i) { GameCollisionHandler->addNewObject(*i); } // The skybox! OgreFW::getSingletonPtr()->m_pSceneMgr->setSkyDome(true, "Examples/CloudySky"); // Activate shadows OgreFW::getSingletonPtr()->m_pSceneMgr->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_MODULATIVE); // Create Lights // Set the ambient light OgreFW::getSingletonPtr()->m_pSceneMgr->setAmbientLight(Ogre::ColourValue(0.15, 0.15, 0.15)); // Create a Directional light Ogre::Light* lptr = OgreFW::getSingletonPtr()->m_pSceneMgr->createLight("dirLight"); lptr->setType(Ogre::Light::LT_DIRECTIONAL); lptr->setDiffuseColour(Ogre::ColourValue(0.4, 0.4, 0)); lptr->setSpecularColour(Ogre::ColourValue(0.4, 0.4, 0)); lptr->setDirection(Ogre::Vector3( 0, -1, 0 )); sceneLights.push_back(lptr); // Create a Point Light Ogre::Light* lptrpoint = OgreFW::getSingletonPtr()->m_pSceneMgr->createLight("pointLight"); lptrpoint->setType(Ogre::Light::LT_POINT); lptrpoint->setPosition(Ogre::Vector3(0, OBJ_SIZE_Y * myLevel->getHeight() * 2, 0)); lptrpoint->setDiffuseColour(1.0, 0.0, 0.0); lptrpoint->setSpecularColour(1.0, 0.0, 0.0); sceneLights.push_back(lptrpoint); // Camera settings - TODO //OgreFW::getSingletonPtr()->moveCameraToPos(Ogre::Vector3( OBJ_SIZE_X, OBJ_SIZE_Y, OBJ_SIZE_Z)); OgreFW::getSingletonPtr()->moveCameraToPos(Ogre::Vector3( myLevel->getWidth() * OBJ_SIZE_X / 2, OBJ_SIZE_Y * myLevel->getHeight() / 2, OBJ_SIZE_Z * 5)); //OgreFW::getSingletonPtr()->setCameraLookAt(Ogre::Vector3(OBJ_SIZE_X * myLevel->getWidth() /2, OBJ_SIZE_Y, 0.0f)); OgreFW::getSingletonPtr()->setCameraLookAt(Ogre::Vector3( myLevel->getWidth() * OBJ_SIZE_X / 2, OBJ_SIZE_Y * (myLevel->getHeight() -1) / 2, 0.0f)); // Set the camerapos for rendering the minimap cameraPosMap = Ogre::Vector3(OBJ_SIZE_X * myLevel->getWidth() / 2, OBJ_SIZE_Y * myLevel->getHeight() / 2, OBJ_SIZE_Z * 10); // Request a sunEffect for creating the sun EffectsFactory::getSingletonPtr()->createSunEffect(myLevel->getWidth() * myLevel->getObjectSide() / 2 , myLevel->getHeight() * myLevel->getObjectSide() / 2 , -60.0f); // We move to the first game state currentGameStage = MAIN_MENU_STATE; // Load the GUI sheet OgreFW::getSingletonPtr()->mGUIRootWindow = CEGUI::WindowManager::getSingleton().loadWindowLayout("myL2.layout"); //CEGUI::Window *guiRoot = CEGUI::WindowManager::getSingleton().getWindow( CEGUI::System::getSingleton().setGUISheet(OgreFW::getSingletonPtr()->mGUIRootWindow); CEGUI::Window* eventButton = OgreFW::getSingletonPtr()->mGUIRootWindow->getChild("MainMenuRoot/LocalGame"); if (eventButton) { std::cout << "Yes I got it" << std::endl; // Register handler eventButton->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::SubscriberSlot(&Game::setupLocalGame, this)); //std::cout << "Text: " << eventButton->getText() << std::endl; } eventButton = OgreFW::getSingletonPtr()->mGUIRootWindow->getChild("MainMenuRoot/NetClient"); if (eventButton) { eventButton->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::SubscriberSlot(&Game::setupClientGame, this)); } eventButton = OgreFW::getSingletonPtr()->mGUIRootWindow->getChild("MainMenuRoot/NetServer"); if (eventButton) { eventButton->subscribeEvent(CEGUI::PushButton::EventClicked, CEGUI::SubscriberSlot(&Game::setupServerGame, this)); } }
OgrePass::OgrePass (OgreMaterial* parent, const std::string& configuration, unsigned short lodIndex) : Pass() { Ogre::Technique* t = parent->getOgreTechniqueForConfiguration(configuration, lodIndex); mPass = t->createPass(); }
/*! Create a color background to show the real scene. \param I : This parameter is here only used to initialize a color background. */ void vpAROgre::createBackground(vpImage<vpRGBa> & /* I */) { // Create a rectangle to show the incoming images from the camera mBackground = new Ogre::Rectangle2D(true); // true = textured mBackground->setCorners(-1.0, 1.0, 1.0, -1.0); // Spread all over the window mBackground->setBoundingBox(Ogre::AxisAlignedBox(-100000.0*Ogre::Vector3::UNIT_SCALE, 100000.0*Ogre::Vector3::UNIT_SCALE)); // To be shown everywhere // Texture options Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_NONE); Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(1); // Dynamic texture // If we are using opengl we can boost a little bit performances with a dynamic texture if(mRoot->getRenderSystem()->getName() == "OpenGL Rendering Subsystem") { Ogre::TextureManager::getSingleton().createManual("BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mBackgroundWidth,//width mBackgroundHeight,//height 0, // num of mip maps //Ogre::PF_BYTE_RGBA, Ogre::PF_BYTE_BGRA, Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE); } else{ // As that texture does not seem to work properly with direct3D we use a default texture Ogre::TextureManager::getSingleton().createManual("BackgroundTexture", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, Ogre::TEX_TYPE_2D, mBackgroundWidth,//width mBackgroundHeight,//height 0, // num of mip maps //Ogre::PF_BYTE_RGBA, Ogre::PF_BYTE_BGRA, Ogre::TU_DEFAULT); } // Pointer to the dynamic texture Ogre::TexturePtr dynTexPtr = Ogre::TextureManager::getSingleton().getByName("BackgroundTexture"); //#if ( OGRE_VERSION >= (1 << 16 | 9 << 8 | 0) ) // .dynamicCast<Ogre::Texture>();// Get the pixel buffer //#else // ; //#endif // Get the pixel buffer mPixelBuffer = dynTexPtr->getBuffer(); // Material to apply the texture to the background Ogre::MaterialPtr Backgroundmaterial = Ogre::MaterialManager::getSingleton().create("BackgroundMaterial", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); //#if ( OGRE_VERSION >= (1 << 16 | 9 << 8 | 0) ) // .dynamicCast<Ogre::Material>(); //#else // ; //#endif Ogre::Technique *Backgroundtechnique = Backgroundmaterial->createTechnique(); Backgroundtechnique->createPass(); Backgroundmaterial->getTechnique(0)->getPass(0)->setLightingEnabled(false); Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthCheckEnabled(false); // Background Backgroundmaterial->getTechnique(0)->getPass(0)->setDepthWriteEnabled(false); // Background Backgroundmaterial->getTechnique(0)->getPass(0)->createTextureUnitState("BackgroundTexture"); mBackground->setMaterial("BackgroundMaterial"); // Attach the material to the rectangle mBackground->setRenderQueueGroup(Ogre::RENDER_QUEUE_BACKGROUND); // To be rendered in Background // Add the background to the Scene Graph so it will be rendered Ogre::SceneNode *BackgroundNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("BackgoundNode"); BackgroundNode->attachObject(mBackground); }