MaterialDocManager.cpp

Go to the documentation of this file.

/*
===========================================================================

Doom 3 GPL Source Code
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 

This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  

Doom 3 Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#include "../../idlib/precompiled.h"
#pragma hdrstop

#include "MaterialDocManager.h"
#include "MaterialView.h"


MaterialDocManager::MaterialDocManager(void) {
        currentMaterial = NULL;
        cutMaterial = false;
}

MaterialDocManager::~MaterialDocManager(void) {
        UnRegisterAllMaterialViews();

        ClearUndo();
        ClearRedo();
}

void MaterialDocManager::RegisterMaterialView(MaterialView* view) {
        ASSERT(view);
        UnRegisterMaterialView(view);
        materialViews.Append(view);

        //Notify the view of myself
        view->SetMaterialDocManager(this);
}

void MaterialDocManager::UnRegisterMaterialView(MaterialView* view) {
        ASSERT(view);
        materialViews.Remove(view);

        //Remove the reference to myself
        view->SetMaterialDocManager(NULL);
}

void MaterialDocManager::UnRegisterAllMaterialViews() {
        
        //Remove the reference to myself
        int c = materialViews.Num();
        for(int i = 0; i < c; i++) {
                materialViews[i]->SetMaterialDocManager(NULL);
        }
        materialViews.Clear();
}

void MaterialDocManager::SetSelectedMaterial(idMaterial* material) {

        bool change = false;

        //Do we need to change the material
        if(material) {
                if(currentMaterial) {
                        if(strcmp(material->GetName(), currentMaterial->renderMaterial->GetName())) {
                                change = true;
                        }
                } else {
                        change = true;
                }
        } else {
                if(currentMaterial) {
                        change = true;
                }
        }
        
        //Now make the change
        if(change) {
                if(currentMaterial) {

                        //Delete the material unless it has been changed
                        if(!inProgressMaterials.Get(currentMaterial->name.c_str())) {
                                delete currentMaterial;
                                currentMaterial = NULL;
                        }
                }

                MaterialDoc** tempDoc;
                if(material && inProgressMaterials.Get(material->GetName(), &tempDoc)) {
                        currentMaterial = *tempDoc;
                        
                } else {
                        currentMaterial = CreateMaterialDoc(material);
                }

                NotifyViews(currentMaterial, SELECTION_CHANGE);
        }
}

bool MaterialDocManager::DoesFileNeedApply(const char* filename) {
        for(int i = 0; i < inProgressMaterials.Num(); i++) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                if(!strcmp((*pDoc)->renderMaterial->GetFileName(), filename) && (*pDoc)->applyWaiting)
                        return true;
        }
        return false;
}

bool MaterialDocManager::DoesAnyNeedApply() {
        for(int i = 0; i < inProgressMaterials.Num(); i++) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                if((*pDoc)->applyWaiting)
                        return true;
        }
        return false;
}

bool MaterialDocManager::IsFileModified(const char* filename) {
        for(int i = 0; i < inProgressMaterials.Num(); i++) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                if(!strcmp((*pDoc)->renderMaterial->GetFileName(), filename))
                        return true;
        }
        return false;
}

bool MaterialDocManager::IsAnyModified() {
        return (inProgressMaterials.Num() > 0);
}

void MaterialDocManager::AddMaterial(const char* name, const char* filename, const char* sourceText, bool addUndo) {
        
        if(addUndo) {
                AddMaterialModifier* mod = new AddMaterialModifier(this, name, filename);
                AddMaterialUndoModifier(mod);
        }

        MaterialDoc* newDoc = new MaterialDoc();
        newDoc->manager = this;
        newDoc->modified = true;
        
        idMaterial* rendMat = (idMaterial*)declManager->CreateNewDecl(DECL_MATERIAL, name, filename);
        
        if(sourceText) {
                rendMat->SetText(sourceText);
        }

        newDoc->SetRenderMaterial(rendMat, true, sourceText ? true : false);

        inProgressMaterials.Set(newDoc->name.c_str(), newDoc);
        
        NotifyViews(newDoc, MATERIAL_ADD);

        //Force an apply so the text will be generated to match the new file
        newDoc->applyWaiting = true;
        newDoc->ApplyMaterialChanges();
}

void MaterialDocManager::RedoAddMaterial(const char* name, bool clearData) {

        MaterialDoc* newDoc = new MaterialDoc();
        newDoc->manager = this;
        newDoc->modified = true;

        idMaterial* rendMat = const_cast<idMaterial *>(declManager->FindMaterial(name, false));

        if(clearData) {
                rendMat->SetText(rendMat->DefaultDefinition());
        }

        newDoc->SetRenderMaterial(rendMat, true, true);

        inProgressMaterials.Set(newDoc->name.c_str(), newDoc);

        NotifyViews(newDoc, MATERIAL_ADD);

        //Force an apply so the text will be generated to match the new file
        newDoc->applyWaiting = true;
        newDoc->ApplyMaterialChanges();
}

void MaterialDocManager::DeleteMaterial(MaterialDoc* material, bool addUndo) {
        
        assert(material);

        //This will just flag for delete. The actual delete will happen during the save
        material->Delete();

        if(addUndo) {
                DeleteMaterialModifier* mod = new DeleteMaterialModifier(this, material->name);
                AddMaterialUndoModifier(mod);
        }

        NotifyViews(material, MATERIAL_DELETE);
}

void MaterialDocManager::ApplyMaterial(MaterialDoc* materialDoc) {
        assert(materialDoc);
        materialDoc->ApplyMaterialChanges();
}

void MaterialDocManager::ApplyFile(const char* filename) {
        
        for(int i = 0; i < inProgressMaterials.Num(); i++) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                if(!strcmp((*pDoc)->renderMaterial->GetFileName(), filename))
                        (*pDoc)->ApplyMaterialChanges();
        }
}

void MaterialDocManager::ApplyAll() {
        for(int i = 0; i < inProgressMaterials.Num(); i++) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                (*pDoc)->ApplyMaterialChanges();
        }
}

void MaterialDocManager::SaveMaterial(MaterialDoc* material) {
        assert(material);
        material->Save();
}

void MaterialDocManager::SaveFile(const char* filename) {
        
        for(int i = inProgressMaterials.Num()-1; i >= 0; i--) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                if(!strcmp((*pDoc)->renderMaterial->GetFileName(), filename))
                        (*pDoc)->Save();
        }

        //Notify everyone
        NotifyViews(NULL, MATERIAL_SAVE_FILE, filename);
}

void MaterialDocManager::SaveAllMaterials() {
        for(int i = inProgressMaterials.Num()-1; i >= 0; i--) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);
                (*pDoc)->Save();
        }
}

void MaterialDocManager::ReloadFile(const char *filename) {
        
        declManager->ReloadFile(filename, true);
                        
        //purge the changes of any in progress materials
        for(int j = inProgressMaterials.Num()-1; j >= 0; j--) {
                MaterialDoc** pDoc = inProgressMaterials.GetIndex(j);
                if(!strcmp((*pDoc)->renderMaterial->GetFileName(), filename)) {
                        (*pDoc)->SetRenderMaterial((*pDoc)->renderMaterial);
                        inProgressMaterials.Remove((*pDoc)->name);
                }
        }
        
        //Reparse the current material
        if(currentMaterial) {
                currentMaterial->SetRenderMaterial(currentMaterial->renderMaterial);

                //Trigger all the views to refresh
                NotifyViews(currentMaterial, SELECTION_CHANGE);
        }

        NotifyViews(NULL, FILE_RELOAD, filename);
}

MaterialDoc* MaterialDocManager::CreateMaterialDoc(const char* materialName) {
        
        const idMaterial* material = declManager->FindMaterial(materialName);
        return CreateMaterialDoc(const_cast<idMaterial *>(material));
}

MaterialDoc* MaterialDocManager::CreateMaterialDoc(idMaterial* material) {

        MaterialDoc* existingDoc = GetInProgressDoc(material);
        if(existingDoc) {
                return existingDoc;
        }

        if(currentMaterial && material && !currentMaterial->name.Icmp(material->GetName())) {
                return currentMaterial;
        }

        if(material) {
                MaterialDoc* newDoc = new MaterialDoc();
                newDoc->manager = this;
                newDoc->SetRenderMaterial(material);
                
                return newDoc;
        }

        return NULL;
}

MaterialDoc* MaterialDocManager::GetInProgressDoc(idMaterial* material) {

        if(material) {
                for(int i = 0; i < inProgressMaterials.Num(); i++) {
                        MaterialDoc** pDoc = inProgressMaterials.GetIndex(i);

                        if(!(*pDoc)->name.Icmp(material->GetName()))
                                return *pDoc;
                }
        }
        return NULL;
}

void MaterialDocManager::CopyMaterial(MaterialDoc* materialDoc, bool cut) {
        
        cutMaterial = cut;

        if(materialDoc)
                copyMaterial = materialDoc->name;
        else
                ClearCopy();
}

void MaterialDocManager::ClearCopy() {
        copyMaterial.Empty();
}

bool MaterialDocManager::IsCopyMaterial() {
        return (copyMaterial.Length() ) ? true : false;
}

idStr MaterialDocManager::GetCopyMaterialName() {
        return copyMaterial;
}

void MaterialDocManager::PasteMaterial(const char* name, const char* filename) {
        
        if(!IsCopyMaterial()) {
                return;
        }

        //Apply the material if there are some changes
        MaterialDoc* copyMat = CreateMaterialDoc(copyMaterial);
        if(copyMat->applyWaiting) {
                copyMat->ApplyMaterialChanges();
        }
        //Paste the material
        idMaterial* material = copyMat->renderMaterial;

        //Add a material with the existing source text
        char *declText = (char *) _alloca( material->GetTextLength() + 1 );
        material->GetText( declText );

        AddMaterial(name, filename, declText, !cutMaterial);

        //If this is a cut then remove the original
        if(cutMaterial) {
                MaterialDoc* cutMaterial = CreateMaterialDoc(material);
                DeleteMaterial(cutMaterial, false);

                MoveMaterialModifier* mod = new MoveMaterialModifier(this, name, filename, copyMaterial);
                AddMaterialUndoModifier(mod);

                ClearCopy();
        }
        
}

void MaterialDocManager::CopyStage(MaterialDoc* materialDoc, int stageNum) {

        assert(materialDoc);

        copyStageMaterial = materialDoc->name;
        copyStage = materialDoc->GetStage(stageNum);
        
        idStr stageName = copyStage.stageData.GetString("name");
}

void MaterialDocManager::ClearCopyStage() {
        copyStageMaterial.Empty();
        copyStage.stageData.Clear();
}

bool MaterialDocManager::IsCopyStage() {
        return (copyStageMaterial.Length() ) ? true : false;
}

void MaterialDocManager::PasteStage(MaterialDoc* materialDoc) {

        assert(materialDoc);

        int stageType = copyStage.stageData.GetInt("stagetype");

        //Create a new stage and copy the data
        materialDoc->AddStage(stageType, copyStage.stageData.GetString("name"));
        materialDoc->SetData(materialDoc->GetStageCount()-1, &copyStage.stageData);
}

void MaterialDocManager::GetCopyStageInfo(int& type, idStr& name) {
        if(IsCopyStage()) {
                type = copyStage.stageData.GetInt("stagetype");
                name = copyStage.stageData.GetString("name");
        }
}

void MaterialDocManager::Undo() {

        if(IsUndoAvailable()) {
                MaterialModifier* mod = undoModifiers[undoModifiers.Num()-1];
                undoModifiers.RemoveIndex(undoModifiers.Num()-1);

                mod->Undo();

                //Add this modifier to the redo list
                AddMaterialRedoModifier(mod);
        }
}

bool MaterialDocManager::IsUndoAvailable() {
        return (undoModifiers.Num() > 0);
}

void MaterialDocManager::ClearUndo() {

        int c = undoModifiers.Num();
        for(int i = 0; i < c; i++) {
                delete undoModifiers[i];
        }
        undoModifiers.Clear();
}

void MaterialDocManager::Redo() {

        if(IsRedoAvailable()) {
                MaterialModifier* mod = redoModifiers[redoModifiers.Num()-1];
                redoModifiers.RemoveIndex(redoModifiers.Num()-1);

                mod->Redo();

                //Done with the mod because the redo process will set 
                //attributes and create the appropriate redo modifier
                AddMaterialUndoModifier(mod, false);            
        }
}

bool MaterialDocManager::IsRedoAvailable() {
        return (redoModifiers.Num() > 0);
}

void MaterialDocManager::ClearRedo() {

        int c = redoModifiers.Num();
        for(int i = 0; i < c; i++) {
                delete redoModifiers[i];
        }
        redoModifiers.Clear();
}

void  MaterialDocManager::AddMaterialUndoModifier(MaterialModifier* mod, bool clearRedo) {
        undoModifiers.Append(mod);

        while(undoModifiers.Num() > MAX_UNDOREDO) {
                undoModifiers.RemoveIndex(0);
        }

        if(clearRedo) {
                ClearRedo();
        }
}

void  MaterialDocManager::AddMaterialRedoModifier(MaterialModifier* mod) {
        redoModifiers.Append(mod);

        while(redoModifiers.Num() > MAX_UNDOREDO) {
                redoModifiers.RemoveIndex(0);
        }
}

bool MaterialDocManager::FindMaterial(const char* name, MaterialSearchData_t* searchData, bool checkName) {

        //Fast way of finding the material without parsing
        const idMaterial* material = static_cast<const idMaterial *>(declManager->FindDeclWithoutParsing(DECL_MATERIAL, name, false));
                
        if(material) {

                int findPos;

                if(checkName) {
                        //Check the name
                        idStr name = material->GetName();

                        findPos = name.Find(searchData->searchText, false);
                        if(findPos != -1) {
                                return true;
                        }
                }

                //Skip to the open braket so the name is not checked
                char *declText = (char *) _alloca( material->GetTextLength() + 1 );
                material->GetText( declText );

                idStr text = declText;
                int start = text.Find("{");
                if(start != -1) {
                        text = text.Right(text.Length()-start);
                }
                
                findPos = text.Find(searchData->searchText, false);
                if(findPos != -1) {
                        //Todo: Include match whole word
                        return true;
                }
        }
        return false;
}

idStr MaterialDocManager::GetUniqueMaterialName(idStr name) {
        int num = 0;
        while(1) {
                idStr testName;
                if(num == 0)
                        testName = name;
                else
                        testName = va("%s%d", name.c_str(), num);

                const idMaterial* mat = declManager->FindMaterial(testName.c_str(), false);
                if(!mat) {
                        return testName;
                } else {

                        //We can reuse delete material names
                        if(mat->GetTextLength() < 1)
                                return testName;
                }
                num++;
        }
}

void MaterialDocManager::NotifyViews(MaterialDoc* materialDoc, int notifyType, ... ) {

        va_list argptr;

        int c = materialViews.Num();
        for(int i = 0; i < c; i++) {
                va_start( argptr, notifyType );
                switch(notifyType) {
                        case SELECTION_CHANGE:
                                materialViews[i]->MV_OnMaterialSelectionChange(materialDoc);
                                break;
                        case MATERIAL_CHANGE:
                                materialViews[i]->MV_OnMaterialChange(materialDoc);
                                break;
                        case MATERIAL_APPLY:
                                materialViews[i]->MV_OnMaterialApply(materialDoc);
                                break;
                        case MATERIAL_SAVE:
                                materialViews[i]->MV_OnMaterialSaved(materialDoc);
                                break;
                        case MATERIAL_SAVE_FILE:
                                materialViews[i]->MV_OnMaterialSaveFile(va_arg(argptr, const char*));
                                break;
                        case MATERIAL_ADD:
                                materialViews[i]->MV_OnMaterialAdd(materialDoc);
                                break;
                        case MATERIAL_DELETE:
                                materialViews[i]->MV_OnMaterialDelete(materialDoc);
                                break;
                        case MATERIAL_ADD_STAGE:
                                materialViews[i]->MV_OnMaterialStageAdd(materialDoc, va_arg(argptr, int));
                                break;
                        case MATERIAL_DELETE_STAGE:
                                materialViews[i]->MV_OnMaterialStageDelete(materialDoc, va_arg(argptr, int));
                                break;
                        case MATERIAL_MOVE_STAGE:
                                {
                                        int from = va_arg(argptr, int);
                                        int to = va_arg(argptr, int);
                                        materialViews[i]->MV_OnMaterialStageMove(materialDoc, from, to);
                                }
                                break;
                        case MATERIAL_ATTRIBUTE_CHANGE:
                                {
                                        int stage = va_arg(argptr, int);
                                        const char* attribName = va_arg(argptr, const char*);
                                        materialViews[i]->MV_OnMaterialAttributeChanged(materialDoc, stage, attribName);
                                }
                                break;
                        case MATERIAL_NAME_CHANGE:
                                {
                                        const char* oldName = va_arg(argptr, const char*);
                                        materialViews[i]->MV_OnMaterialNameChanged(materialDoc, oldName);
                                }
                                break;
                        case FILE_RELOAD:
                                {
                                        const char* filename = va_arg(argptr, const char*);
                                        materialViews[i]->MV_OnFileReload(filename);
                                }
                                break;
                }
                va_end( argptr );
        }
}

void MaterialDocManager::MaterialChanged(MaterialDoc* materialDoc) {

        //Make sure this material is in our list of changed materials
        if(!inProgressMaterials.Get(materialDoc->name.c_str())) {
                inProgressMaterials.Set(materialDoc->name.c_str(), materialDoc);
        }

        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_CHANGE);
}

void MaterialDocManager::MaterialApplied(MaterialDoc* materialDoc) {

        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_APPLY);
}

void MaterialDocManager::MaterialSaved(MaterialDoc* materialDoc) {

        MaterialDoc** tempDoc;
        if(inProgressMaterials.Get(materialDoc->name.c_str(), &tempDoc)) {

                idStr name = materialDoc->name.c_str();

                //Remove this file from our in progress list
                inProgressMaterials.Remove(name.c_str());

                //Notify everyone
                NotifyViews(materialDoc, MATERIAL_SAVE);

                if(materialDoc != currentMaterial)
                        delete materialDoc;
        }
}

void MaterialDocManager::MaterialNameChanged(const char* oldName, MaterialDoc* materialDoc) {

        MaterialDoc** tempDoc;
        if(inProgressMaterials.Get(oldName, &tempDoc)) {
                inProgressMaterials.Set(materialDoc->name, *tempDoc);
                inProgressMaterials.Remove(oldName);
        }

        NotifyViews(materialDoc, MATERIAL_NAME_CHANGE, oldName);
}

void MaterialDocManager::StageAdded(MaterialDoc* materialDoc, int stageNum) {
        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_ADD_STAGE, stageNum);
}

void MaterialDocManager::StageDeleted(MaterialDoc* materialDoc, int stageNum) {
        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_DELETE_STAGE, stageNum);
}

void MaterialDocManager::StageMoved(MaterialDoc* materialDoc, int from, int to) {
        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_MOVE_STAGE, from, to);
}

void MaterialDocManager::AttributeChanged(MaterialDoc* materialDoc, int stage, const char* attribName) {
        //Notify everyone
        NotifyViews(materialDoc, MATERIAL_ATTRIBUTE_CHANGE, stage, attribName);
}