/** * Sets an attribute bool in the material or a stage. * @param stage The stage or -1 for the material. * @param attribName The name of the attribute. * @param value The value to set. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::SetAttributeBool(int stage, const char* attribName, bool value, bool addUndo) { //Make sure we need to set the attribute bool orig = GetAttributeBool(stage, attribName); if(orig != value) { idDict* dict; if(stage == -1) { dict = &editMaterial.materialData; } else { assert(stage >= 0 && stage < GetStageCount()); dict = &editMaterial.stages[stage]->stageData; } if(addUndo) { //Create a new Modifier for this change so we can undo and redo later AttributeMaterialModifierBool* mod = new AttributeMaterialModifierBool(manager, name, stage, attribName, value, orig); manager->AddMaterialUndoModifier(mod); } dict->SetBool(attribName, value); manager->AttributeChanged(this, stage, attribName); OnMaterialChanged(); } }
/** * Moves a stage from one location to another. * @param from The original location of the stage. * @param to The new location of the stage. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::MoveStage(int from, int to, bool addUndo) { assert(from >= 0 && from < GetStageCount()); assert(to >= 0 && to < GetStageCount()); int origFrom = from; int origTo = to; if(from < to) to++; MEStage_t* pMove = editMaterial.stages[from]; editMaterial.stages.Insert(pMove, to); if(from > to) from++; editMaterial.stages.RemoveIndex(from); manager->StageMoved(this, origFrom, origTo); if(addUndo) { StageMoveModifier *mod = new StageMoveModifier(manager, name, origFrom, origTo); manager->AddMaterialUndoModifier(mod); } OnMaterialChanged(); }
/** * Specifies the enabled state of a single stage. * @param stage The stage to change. * @param enabled The enabled state. */ void MaterialDoc::EnableStage(int stage, bool enabled) { assert(stage >= 0 && stage < GetStageCount()); editMaterial.stages[stage]->enabled = enabled; OnMaterialChanged(); }
/** * Removes a stage from the material. * @param stage The stage to remove. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::RemoveStage(int stage, bool addUndo) { assert(stage >= 0 && stage < GetStageCount()); if(addUndo) { //Add modifier to undo this operation StageDeleteModifier* mod = new StageDeleteModifier(manager, name, stage, editMaterial.stages[stage]->stageData); manager->AddMaterialUndoModifier(mod); } //delete the stage and remove it from the list delete editMaterial.stages[stage]; editMaterial.stages.RemoveIndex(stage); manager->StageDeleted(this, stage); OnMaterialChanged(); }
/** * Inserts a new stage to the material at a specified location. * @param stage The location to insert the stage. * @param stageType The type of the stage: normal or special. * @param stageName The name of the stage. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::InsertStage(int stage, int stageType, const char* stageName, bool addUndo) { MEStage_t* newStage = new MEStage_t(); editMaterial.stages.Insert(newStage, stage); newStage->stageData.Set("name", stageName); newStage->stageData.SetInt("stagetype", stageType); newStage->enabled = true; if(addUndo) { StageInsertModifier* mod = new StageInsertModifier(manager, name, stage, stageType, stageName); manager->AddMaterialUndoModifier(mod); } manager->StageAdded(this, stage); OnMaterialChanged(); }
/** * Sets the material name. * @param materialName The new name of the material. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::SetMaterialName(const char* materialName, bool addUndo) { idStr oldName = name; declManager->RenameDecl(DECL_MATERIAL, oldName, materialName); name = renderMaterial->GetName(); if(addUndo) { RenameMaterialModifier* mod = new RenameMaterialModifier(manager, name, oldName); manager->AddMaterialUndoModifier(mod); } manager->MaterialNameChanged(oldName, this); OnMaterialChanged(); //Need to do an instant apply for material name changes ApplyMaterialChanges(); }
void IMaterial::AddTexture(ITexture* texture) { MEDUSA_ASSERT_NOT_NULL(texture, ""); MEDUSA_ASSERT_FALSE(mTextures.ContainsKey(texture->Unit()), "Duplicate add texture of same unit"); MEDUSA_ASSERT_FALSE(mTextureSamplerDict.ContainsKey(texture->SamplerName()), "Duplicate add texture of same sampler name"); texture->Retain(); mTextures.Add(texture->Unit(), texture); mTextureSamplerDict.Add(texture->SamplerName(), texture); OnMaterialChanged(RenderableChangedFlags::BatchChanged); EnableBlend(texture->IsBlend()); if (mFirstTexture == nullptr) { mFirstTexture = texture; } }
/** * Sets an attribute float in the material or a stage. * @param stage The stage or -1 for the material. * @param attribName The name of the attribute. * @param value The value to set. * @param addUndo Flag that specifies if the system should add an undo operation. */ void MaterialDoc::SetAttributeFloat(int stage, const char* attribName, float value, bool addUndo) { //Make sure we need to set the attribute float orig = GetAttributeFloat(stage, attribName); if(orig != value) { idDict* dict; if(stage == -1) { dict = &editMaterial.materialData; } else { assert(stage >= 0 && stage < GetStageCount()); dict = &editMaterial.stages[stage]->stageData; } dict->SetFloat(attribName, value); manager->AttributeChanged(this, stage, attribName); OnMaterialChanged(); } }
/** * Deletes the material. */ void MaterialDoc::Delete() { deleted = true; OnMaterialChanged(); }
/** * Called when the editor modifies the source of the material. * @param text The new source text. */ void MaterialDoc::SourceModify(SourceModifyOwner* owner) { sourceModifyOwner = owner; sourceModify = true; OnMaterialChanged(); }