void MaterialVar_Integer::updateObject() { if (!updating && getMaterial() && getMaterial()->getVar(getMaterialVarIndex())) { Magic3D::MaterialVar_Integer* variable = (Magic3D::MaterialVar_Integer*)getMaterial()->getVar(getMaterialVarIndex()); if (ui->txtX->isVisible()) { variable->setValue(0, ui->txtX->value()); } if (ui->txtY->isVisible()) { variable->setValue(1, ui->txtY->value()); } if (ui->txtZ->isVisible()) { variable->setValue(2, ui->txtZ->value()); } if (ui->txtW->isVisible()) { variable->setValue(3, ui->txtW->value()); } needSave(); update(); mainWindow->update(); } }
void SuperGeometry2D::checkForErrors() { bool Error = false; for (int iX = 0; iX < _nx; iX++) { for (int iY = 0; iY < _ny; iY++) { if (getMaterial(iX, iY) == 0) { if ( getMaterial(iX - 1, iY ) == 1 || getMaterial(iX, iY - 1) == 1 || getMaterial(iX - 1, iY - 1) == 1 || getMaterial(iX + 1, iY ) == 1 || getMaterial(iX, iY + 1) == 1 || getMaterial(iX + 1, iY + 1) == 1 || getMaterial(iX - 1, iY + 1) == 1 || getMaterial(iX + 1, iY - 1) == 1) { Error = true; } } } } if (Error == true) { clout << "error!" << std::endl; } else { clout << "the model is correct!" << std::endl; } }
/*! \todo move all except the default shader to config file */ void iMaterialResourceFactory::initDefaultMaterial() { _defaultID = createMaterial(); getMaterial(_defaultID)->setName("IgorDefault"); getMaterial(_defaultID)->addShaderSource("default.vert", iShaderObjectType::Vertex); getMaterial(_defaultID)->addShaderSource("default_directional_light.frag", iShaderObjectType::Fragment); getMaterial(_defaultID)->compileShader(); getMaterial(_defaultID)->getRenderStateSet().setRenderState(iRenderState::Texture2D0, iRenderStateValue::Off); getMaterialGroup(_defaultID)->setOrder(iMaterial::RENDER_ORDER_DEFAULT); // set material to start with setMaterial(_defaultID); }
int getTotalTableMaterial(Board *board) { int material; //calculating the material for the white and the black int material_white= getMaterial(board,WHITE); int material_black= getMaterial(board,BLACK); if(board->myColor==BLACK) material=material_black-material_white; //If I am black I have to use the black material first else material=material_white-material_black; return material; }
CShaderPostProcess::CShaderPostProcess(IrrlichtDevice* device, const core::stringc& name, io::path vsFile, core::stringc vsEntry, video::E_VERTEX_SHADER_TYPE vsType, io::path psFile, core::stringc psEntry, video::E_PIXEL_SHADER_TYPE psType, video::E_MATERIAL_TYPE baseMaterial) : IPostProcess(name), Device(device) { // get the shader material fomr the material manager ShaderMaterial = new CShaderMaterial(device, name, vsFile, vsEntry, vsType, psFile, psEntry, psType, baseMaterial); // set material parameters getMaterial().Lighting = false; getMaterial().BackfaceCulling = false; getMaterial().ZBuffer = video::ECFN_NEVER; }
void Butter::draw() { glPushMatrix(); glTranslatef(_position->getX(), _position->getY(), _position->getZ()); glPushMatrix(); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, getMaterial()->getAmbient()); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, getMaterial()->getDiffuse()); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, getMaterial()->getSpecular()); glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, getMaterial()->getShine()); glScalef(0.3, 0.3, 0.3); glTranslatef(0, 0, 10); glRotated(90, 1, 0, 0); glPushMatrix(); glScalef(3.0f, 3.0f, 3.0f); glPushMatrix(); glColor3f(0.9f, 0.8f, 0.1f); glTranslatef(1, -1.5, 1.0); glScalef(1.0f, 0.1f, 1.0f); glutSolidSphere(4, 10, 10); glPopMatrix(); glPushMatrix(); glColor3f(0.95f, 0.8f, 0.1f); glTranslatef(4, -1.5, 1.0); glScalef(1.0f, 0.1f, 1.0f); glutSolidSphere(2, 10, 10); glPopMatrix(); glPushMatrix(); glColor3f(0.95f, 0.8f, 0.1f); glTranslatef(1, -1.5, 3.7); glScalef(1.0f, 0.1f, 1.0f); glutSolidSphere(1.7, 10, 10); glPopMatrix(); glPushMatrix(); glColor3f(0.95f, 0.8f, 0.1f); glTranslatef(3.2, -1.5, 3.2); glScalef(1.0f, 0.1f, 1.0f); glutSolidSphere(1.7, 10, 10); glPopMatrix(); glPushMatrix(); glColor3f(1.0f, 0.8f, 0.0f); glScalef(1.0f, 0.5f, 1.5f); glutSolidCube(6); glPopMatrix(); glPopMatrix(); glPopMatrix(); glPopMatrix(); }
void LD3dsExporter::writeTriangle( VertexVector &vecVertices, FaceVector &vecFaces, const TCVector *points, int i0, int i1, int i2, int colorNumber, const TCFloat *matrix) { int ix[3]; int voffset = (int)vecVertices.size(); int foffset = (int)vecFaces.size(); ix[0] = i0; ix[1] = i1; ix[2] = i2; vecVertices.resize(vecVertices.size() + 3); vecFaces.resize(vecFaces.size() + 1); for (int i = 0; i < 3; i++) { TCVector vector = points[ix[i]]; vector = vector.transformPoint(matrix); vecVertices[voffset + i].v[0] = vector[0]; vecVertices[voffset + i].v[1] = vector[1]; vecVertices[voffset + i].v[2] = vector[2]; vecFaces[foffset].index[i] = (unsigned short)(voffset + i); vecFaces[foffset].material = getMaterial(colorNumber); } }
RenderKey meshrenderer::createRenderKey(MeshRenderer& renderer) { RenderKey key; if(renderer.material != -1) { Material& mat = getMaterial(renderer.material); if(mat._flags & MAT_TRANSPARENT) { key.sortKey.transparent = 1; } else { key.sortKey.transparent = 0; key.sortKey.op_material = renderer.material; key.sortKey.op_shader = mat._shader; } key.shader = mat._shader; key.statedat = mat.states; } key.material = renderer.material; key.mesh = renderer.mesh; if(renderer.transform != -1) { key.transform = getTransform(renderer.transform)._matrix; } return key; }
// get material ID short getMaterialID (PyObject * obj, char * name) { // search for material for (short matID = 0;; ++matID) { // get material RAS_IPolyMaterial * mat = getMaterial(obj, matID); // if material is not available, report that no material was found if (mat == NULL) break; // name is a material name if it starts with MA and a UV texture name if it starts with IM if (name[0] == 'I' && name[1] == 'M') { // if texture name matches if (strcmp(mat->GetTextureName().ReadPtr(), name) == 0) return matID; } else { // if material name matches if (strcmp(mat->GetMaterialName().ReadPtr(), name) == 0) return matID; } } // material was not found return -1; }
/* ============================================================================= =============================================================================== */ void C3DModel::reloadMaterials() { string strTempPath; if (!OpenKMZFile("", strTempPath)) return; for (int i = 0; i < getMaterialCnt(); i++) { deleteTexture(getMaterial(i).getTextureId()); int w, h; GLuint txID = createTexture(getMaterial(i).getLink(), w, h, TX_CLAMP_EDGE); editMaterial(i).setTextureId(txID); editMaterial(i).setHeight(h); editMaterial(i).setWidth(w); } }
reMesh* reFBXAsset::importMesh(FbxNode* fbxNode) { qDebug() << "import mesh for" << fbxNode->GetName(); reMesh* mesh = new reMesh; FbxMesh* fmesh = (FbxMesh*) fbxNode->GetNodeAttribute(); FbxVector4* controlPoints = fmesh->GetControlPoints(); for (int i=0; i<fmesh->GetPolygonCount(); i++) { reFace* face = new reFace; for (int j=0; j<fmesh->GetPolygonSize(i); j++) { int vi = fmesh->GetPolygonVertex(i, j); reVertex vertex; vertex.pos = reVec3(controlPoints[vi][0], controlPoints[vi][1], controlPoints[vi][2]); FbxVector4 fNormal; fmesh->GetPolygonVertexNormal(i, j, fNormal); vertex.uv = getUV(fmesh, vi, i, j); vertex.normal = reVec3(fNormal[0], fNormal[1], fNormal[2]); face->vertices.push_back(vertex); } reMaterial* mat = getMaterial(fmesh, i, mesh->materialSet); mesh->addFace(face,mat ? mat->id: -1); } reMeshAsset* meshAsset = new reMeshAsset(meshes); meshAsset->mesh = mesh; meshes->children.push_back(meshAsset); meshAsset->setPath((dataDir().toStdString() + "/" + fbxNode->GetName() + ".mesh").c_str()); mesh->save(dataDir().toStdString() + "/" + fbxNode->GetName() + ".mesh"); return mesh; }
void MaterialEntityItem::removeMaterial() { graphics::MaterialPointer material = getMaterial(); if (!material) { return; } QUuid parentID = getParentID(); if (parentID.isNull()) { return; } // Our parent could be an entity, an avatar, or an overlay if (EntityTree::removeMaterialFromEntity(parentID, material, getParentMaterialName().toStdString())) { return; } if (EntityTree::removeMaterialFromAvatar(parentID, material, getParentMaterialName().toStdString())) { return; } if (EntityTree::removeMaterialFromOverlay(parentID, material, getParentMaterialName().toStdString())) { return; } // if a remove fails, our parent is gone, so we don't need to retry }
ComputeReturnMappingStress::ComputeReturnMappingStress(const InputParameters & parameters) : ComputeFiniteStrainElasticStress(parameters), _elastic_strain_old(declarePropertyOld<RankTwoTensor>(_base_name + "elastic_strain")), _inelastic_strain_increment(getMaterialProperty<RankTwoTensor>("inelastic_strain_increment")), _recompute_return_material(getMaterial("return_mapping_stress_model")) { }
void SceneManager::vist(const NodePtr &node) { if (node->getEntity()->getTransform()->refreshFlags & Transform::RF_LOCAL_TRANSFORM) { this->sceneTransformUpdateBucket.push_back(node); } if (node->isVisible()) { auto renderElement = node->getComponent<RenderElement>(); if (renderElement) { auto transform = node->getEntity()->getTransform(); auto material = renderElement->getMaterial(); auto mesh = renderElement->getMesh(); this->renderManger.getRenderQueue().addRenderable(transform->getWorldMatrix(), material, mesh->getMeshData(), material->getQueueID()); } else if (node->getComponent<ui::ElementBatcher>()) { auto batcher = node->getComponent<ui::ElementBatcher>(); batcher->Render(); } for (auto& child : node->getChildren()) { this->vist(child); } } }
void CMultiTexturingTerrainSceneNode::render() { //CTerrainSceneNode::render(); //I learned this meshbuffer trick from Viz_Fuerte's "Simple but useful projects" if (!SceneManager->isCulled(this)) { /*setVisible(true); OnRegisterSceneNode(); updateAbsolutePosition(); setVisible(false);*/ //Reset the transformation SceneManager->getVideoDriver()->setTransform(video::ETS_WORLD, core::IdentityMatrix); for (u32 i = 0; i < array_Passes.size(); i++) { setMaterialTexture(0, array_Passes[i]->splat_texture); setMaterialTexture(1, array_Passes[i]->red_texture); setMaterialTexture(2, array_Passes[i]->green_texture); setMaterialTexture(3, array_Passes[i]->blue_texture); video::SMaterial material = getMaterial(0); material.MaterialType = (video::E_MATERIAL_TYPE)shaderMaterial; material.MaterialTypeParam = video::pack_textureBlendFunc(video::EBF_DST_COLOR, video::EBF_ONE); SceneManager->getVideoDriver()->setMaterial(material); SceneManager->getVideoDriver()->drawMeshBuffer(getRenderBuffer()); } } }
void TrussMaterialLibrary::selectMaterial ( int idx ) { TrussMaterial* material = getMaterial( idx ); if ( material ) selectMaterial( *material ); }
void TrussMaterialLibrary::selectMaterial ( const QString& uuid ) { TrussMaterial* material = getMaterial( uuid ); if ( material ) selectMaterial( *material ); }
bool Sphere::intersect(const Ray& ray, Intersection& inter) { Vector temp = ray.o - center; float a = dot(ray.d, ray.d); float b = 2 * dot(temp, ray.d); float c = dot(temp, temp) - radius * radius; float t1, t2; if (solveQuadratic(a, b, c, &t1, &t2)) { float t = std::min(t1, t2); if (t > EPSILON && t < inter.t) { ray.rayEpsilon = 1e-3f * t; inter.normal = (temp + ray.d * t) / radius; inter.ray = ray; inter.t = t; inter.hitPoint = ray(t); inter.hitObject = true; inter.material = getMaterial(); return true; } } return false; }
void Collider::_copyFrom(const ComponentBase *model) { auto m = (Collider*)model; if (m->getColliderType() == Physics::ColliderType::Mesh) { init(m->getColliderType(), m->getMesh()); } else { init(m->getColliderType(), ""); } #ifdef EDITOR_ENABLED editorUpdate(); if (editorStruct) { editorStruct->copyDatas(m); } Link *link = entity.getLinkPtr(); auto p = scaleFromMat4(link->getGlobalTransform()); //scale(p / getSize()); #else setMaterial(m->getMaterial()->getName()); setAsTrigger(m->isATrigger()); setFilterGroup(m->getFilterGroup()); setCenter(m->getCenter()); setHeight(m->getHeight()); setRadius(m->getRadius()); setSize(m->getSize()); setMesh(m->getMesh()); if (m->isConvex()) setAsConvex(); else if (m->isConcave()) setAsConcave(); #endif }
void DeferredLight::updateFromCamera(Ogre::Camera* camera) { const Ogre::MaterialPtr& mat = getMaterial(); if (!mat->isLoaded()) { mat->load(); } Ogre::Technique* tech = mat->getBestTechnique(); Ogre::Vector3 farCorner = camera->getViewMatrix(true) * camera->getWorldSpaceCorners()[4]; for (unsigned short i=0; i<tech->getNumPasses(); i++) { Ogre::Pass* pass = tech->getPass(i); Ogre::GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters(); if (params->_findNamedConstantDefinition("farCorner")) params->setNamedConstant("farCorner", farCorner); params = pass->getFragmentProgramParameters(); if (params->_findNamedConstantDefinition("farCorner")) params->setNamedConstant("farCorner", farCorner); // If inside light geometry, render back faces with CMPF_GREATER, otherwise normally if (mParentLight->getType() == Ogre::Light::LT_DIRECTIONAL) { pass->setCullingMode(Ogre::CULL_CLOCKWISE); pass->setDepthCheckEnabled(false); } else { pass->setDepthCheckEnabled(true); if (isCameraInsideLight(camera)) { pass->setCullingMode(Ogre::CULL_ANTICLOCKWISE); pass->setDepthFunction(Ogre::CMPF_GREATER_EQUAL); } else { pass->setCullingMode(Ogre::CULL_CLOCKWISE); pass->setDepthFunction(Ogre::CMPF_LESS_EQUAL); } } Ogre::Camera shadowCam("ShadowCameraSetupCam", 0); shadowCam._notifyViewport(camera->getViewport()); Ogre::SceneManager* sm = mParentLight->_getManager(); sm->getShadowCameraSetup()->getShadowCamera(sm, camera, camera->getViewport(), mParentLight, &shadowCam, 0); //Get the shadow camera position if (params->_findNamedConstantDefinition("shadowCamPos")) { params->setNamedConstant("shadowCamPos", shadowCam.getPosition()); } if (params->_findNamedConstantDefinition("shadowFarClip")) { params->setNamedConstant("shadowFarClip", shadowCam.getFarClipDistance()); } } }
//----------------------------------------------------------------------- void PrimitiveShapeSet::rotateTexture(Ogre::Real speed) { // Get the material and rotate it, assume the material is loaded already, otherwise skip. Ogre::MaterialPtr material = getMaterial(); if (material.isNull()) return; Ogre::TextureUnitState::EffectMap::const_iterator it; unsigned short numberOfTechniques = material->getNumTechniques(); for (unsigned short u = 0; u < numberOfTechniques; ++u) { Ogre::Technique* technique = material->getTechnique(u); unsigned short numberOfPasses = technique->getNumPasses(); for (unsigned short v = 0; v < numberOfPasses; ++v) { Ogre::Pass* pass = technique->getPass(v); unsigned short numberOfTextureUnitStates = pass->getNumTextureUnitStates(); for (unsigned short w = 0; w < numberOfTextureUnitStates; ++w) { // Set the rotation if not already available. // This can only be done once! Changing the rotationspeed or removing the rotation // and resetting it doesn´t seem to work. Ogre::TextureUnitState* textureUnitState = pass->getTextureUnitState(w); it = textureUnitState->getEffects().find(Ogre::TextureUnitState::ET_ROTATE); if (it == textureUnitState->getEffects().end()) { textureUnitState->setRotateAnimation(speed); } } } } }
void WorkspacePanel::OnNewTechnique(wxCommandEvent& event) { Project* project = NULL; MaterialController* material = NULL; wxTreeItemId selId = mTreeCtrl->GetSelection(); if(isProject(selId)) { project = getProject(selId); } else if(isMaterial(selId)) { wxTreeItemId projectId = mTreeCtrl->GetItemParent(selId); project = getProject(projectId); material = getMaterial(selId); } TechniqueWizard* wizard = new TechniqueWizard(); wizard->Create(this, wxID_ANY, wxT("New Technique"), wxNullBitmap, wxDefaultPosition, wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER); wizard->getTechniquePage()->setProject(project); wizard->getTechniquePage()->setMaterial(material); wizard->RunWizard(wizard->getTechniquePage()); // This seems unnatural, seems there must be a better way to deal with wizards wizard->Destroy(); delete wizard; }
void SuperGeometry2D::refineMesh(int level) { // new number of Voxels in X-,Y-,and Z-direction and new spacing int _nXnew = level * _nx; int _nYnew = level * _ny; double _hnew = _h / ((double) level); olb::ScalarField2D<unsigned short> _refinedGeometryData(_nXnew, _nYnew); _refinedGeometryData.construct(); for (int iX = 0; iX < _nx; iX++) { for (int iY = 0; iY < _ny; iY++) { for (int li = 0; li < level; li++) { for (int lj = 0; lj < level; lj++) { _refinedGeometryData.get(level * iX + li, level * iY + lj) = getMaterial( iX, iY); } } } } for (int iX = 0; iX < _nXnew; iX++) { for (int iY = 0; iY < _nYnew; iY++) { if (iX == 0 || iY == 0 || iX == _nXnew - 1 || iY == _nYnew - 1) _refinedGeometryData.get(iX, iY) = 0; } } reInit(_x0, _y0, _hnew, _nXnew - 2, _nYnew - 2, 1, &_refinedGeometryData); }
void WorkspacePanel::OnEdit(wxCommandEvent& event) { wxTreeItemId selId = mTreeCtrl->GetSelection(); if(isMaterial(selId)) { MaterialController* mc = getMaterial(selId); EditorManager* editorManager = EditorManager::getSingletonPtr(); Editor* editor = editorManager->findEditor(mc->getMaterial()->getName().c_str()); Editor* editorMat = editorManager->findEditor(Ogre::String(mc->getMaterial()->getName() + ".material").c_str()); if(editor != NULL) { editorManager->setActiveEditor(editor); } else if(editorMat != NULL) { editorManager->setActiveEditor(editorMat); } else { MaterialSerializer* ms = new MaterialSerializer(); ms->queueForExport(mc->getMaterial(), true); String script = ms->getQueuedAsString(); MaterialScriptEditor* materialEditor = new MaterialScriptEditor(editorManager->getEditorNotebook(), wxID_ANY); wxString name = mc->getMaterial()->getName().c_str(); name += wxT(".material"); materialEditor->setName(name); materialEditor->SetText(script); editorManager->openEditor(materialEditor); } } }
const c8* CTextSceneNode::getSceneCorePropertiesXMLString() { core::stringc str; static core::stringc xmlstr; xmlstr = ""; if (getMaterialsCount() == 1) { const c8* mat_xml = SCENE_MANAGER.getMaterialXMLText(getMaterial(0)); xmlstr.append(mat_xml); } str.sprintf( "<Font filename=\"%s\" size=\"%d/\" />\n", m_Font->getFileName(), m_Font->getSize() ); xmlstr.append(str); str.sprintf( "<Text value=\"%s\" />\n", core::stringc(getText()).c_str() ); xmlstr.append(str); img::SColor c = getTextColor(); str.sprintf( "<TextColor value=\"%d,%d,%d,%d\" />\n", c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha() ); xmlstr.append(str); return xmlstr.c_str(); }
void MaterialEntityItem::applyMaterial() { _retryApply = false; graphics::MaterialPointer material = getMaterial(); QUuid parentID = getClientOnly() ? getOwningAvatarID() : getParentID(); if (!material || parentID.isNull()) { return; } Transform textureTransform; textureTransform.setTranslation(glm::vec3(_materialMappingPos, 0)); textureTransform.setRotation(glm::vec3(0, 0, glm::radians(_materialMappingRot))); textureTransform.setScale(glm::vec3(_materialMappingScale, 1)); material->setTextureTransforms(textureTransform); graphics::MaterialLayer materialLayer = graphics::MaterialLayer(material, getPriority()); // Our parent could be an entity, an avatar, or an overlay if (EntityTree::addMaterialToEntity(parentID, materialLayer, getParentMaterialName().toStdString())) { return; } if (EntityTree::addMaterialToAvatar(parentID, materialLayer, getParentMaterialName().toStdString())) { return; } if (EntityTree::addMaterialToOverlay(parentID, materialLayer, getParentMaterialName().toStdString())) { return; } // if we've reached this point, we couldn't find our parent, so we need to try again later _retryApply = true; }
void RenderGlowMgr::addElement( RenderInst *inst ) { // Skip out if we don't have the glow post // effect enabled at this time. if ( !isGlowEnabled() ) return; // TODO: We need to get the scene state here in a more reliable // manner so we can skip glow in a non-diffuse render pass. //if ( !mParentManager->getSceneManager()->getSceneState()->isDiffusePass() ) //return RenderBinManager::arSkipped; ParticleRenderInst *particleInst = NULL; if(inst->type == RenderPassManager::RIT_Particle) particleInst = static_cast<ParticleRenderInst*>(inst); if(particleInst && particleInst->glow) { internalAddElement(inst); return; } // Skip it if we don't have a glowing material. BaseMatInstance *matInst = getMaterial( inst ); if ( !matInst || !matInst->hasGlow() ) return; internalAddElement(inst); }
void TrussMaterialLibrary::loadFromXML ( const QDomElement& projElem ) /*throw (LoadException)*/ { XMLSerializableObject::loadFromXML( projElem ); clean(); /** * Create materials ********************/ QDomNodeList trussMaterials = projElem.elementsByTagName( "TrussMaterial" ); for ( int i = 0; i < trussMaterials.count(); ++i ) { QDomNode material = trussMaterials.item( i ); if ( ! material.isElement() ) throw LoadException(); QDomElement materialElem = material.toElement(); TrussMaterial& newMaterial = createMaterial( 0, 0, 0, "" ); newMaterial.loadFromXML( materialElem ); } /** * Set selected material ************************/ if ( ! projElem.hasAttribute( "selectedMaterial" ) ) throw LoadException(); QString mUUID = projElem.attribute( "selectedMaterial" ); TrussMaterial* m = getMaterial( mUUID ); if ( m ) selectMaterial( *m ); }
ParticleSystemProxy::ParticleSystemProxy(bool createDefaultEmitter, ISceneNode* parent, scene::ISceneManager* mgr, s32 id, const core::vector3df& position, const core::vector3df& rotation, const core::vector3df& scale) : CParticleSystemSceneNode(createDefaultEmitter, parent, mgr, id, position, rotation, scale), m_alpha_additive(false) { initGL(); fakemat.Lighting = false; fakemat.ZWriteEnable = false; fakemat.MaterialType = irr_driver->getShader(ES_RAIN); fakemat.setTexture(0, getMaterial(0).getTexture(0)); fakemat.BlendOperation = video::EBO_NONE; fakemat.FrontfaceCulling = false; fakemat.BackfaceCulling = false; glGenBuffers(1, &initial_values_buffer); glGenBuffers(2, tfb_buffers); glGenBuffers(1, &quaternionsbuffer); size_increase_factor = 0.; if (quad_vertex_buffer) return; static const GLfloat quad_vertex[] = { -.5, -.5, 0., 0., .5, -.5, 1., 0., -.5, .5, 0., 1., .5, .5, 1., 1., }; glGenBuffers(1, &quad_vertex_buffer); glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(quad_vertex), quad_vertex, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); }
bool Representation::doWakeUp() { if (getMaterial() == nullptr && !m_materialReference.empty()) { std::vector<std::string> names; boost::split(names, m_materialReference, boost::is_any_of("/")); SURGSIM_ASSERT(names.size() == 2) << "Material reference needs to have 2 parts <scenelement>/<component>, '" << m_materialReference << "' in " << getFullName() << " doesn't."; auto material = getScene()->getComponent(names[0], names[1]); if (material != nullptr) { setMaterial(material); } else { SURGSIM_LOG_WARNING(Framework::Logger::getLogger("Graphics/Representation")) << "Can't find material " << m_materialReference << " in Scene, rendering of " << getFullName() << " is going to be compromised."; } } return true; }