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;
}
