Creating StaticModel components, drag/drop of model and material in inspector

Script/AtomicEditor/ui/inspector/ComponentInspector.ts

@@ -101,20 +101,22 @@ class ComponentInspector extends Atomic.UISection {
 
         }
 
-        if (component.getTypeName() == "PrefabComponent") {
-
+        // custom component UI
+        if (component.typeName == "PrefabComponent") {
             this.addPrefabUI(attrsVerticalLayout);
-
         }
 
-        if (component.getTypeName() == "Light") {
+        if (component.typeName == "Light") {
             this.addLightCascadeParametersUI(attrsVerticalLayout);
         }
 
-        if (component.getTypeName() == "JSComponent") {
+        if (component.typeName == "JSComponent") {
             this.addJSComponentUI(attrsVerticalLayout);
         }
 
+        if (component.typeName == "StaticModel") {
+            this.addStaticModelUI(attrsVerticalLayout);
+        }
 
         var deleteButton = new Atomic.UIButton();
         deleteButton.text = "Delete Component";
@@ -170,6 +172,112 @@ class ComponentInspector extends Atomic.UISection {
 
     }
 
+    acceptAssetDrag(importerTypeName: string, ev: Atomic.DragEndedEvent): ToolCore.AssetImporter {
+
+        var dragObject = ev.dragObject;
+
+        if (dragObject.object && dragObject.object.typeName == "Asset") {
+
+            var asset = <ToolCore.Asset> dragObject.object;
+
+            if (asset.importerTypeName == importerTypeName) {
+                return asset.importer;
+            }
+
+        }
+
+        return null;
+
+    }
+
+    addStaticModelUI(layout: Atomic.UILayout) {
+
+        var staticModel = <Atomic.StaticModel> this.component;
+        var cacheModel = staticModel.model;
+
+        // MODEL FIELD
+        var field = InspectorUtils.createAttrEditField("Model", layout);
+        field.readOnly = true;
+
+        if (cacheModel) {
+
+            var asset = ToolCore.assetDatabase.getAssetByCachePath(cacheModel.name);
+
+            if (asset) {
+
+                field.text = asset.name;
+
+            }
+
+        }
+
+        // handle dropping of model on field
+        field.subscribeToEvent(field, "DragEnded", (ev: Atomic.DragEndedEvent) => {
+
+            if (ev.target == field) {
+
+                var importer = this.acceptAssetDrag("ModelImporter", ev);
+
+                if (importer) {
+
+                    var modelImporter = <ToolCore.ModelImporter> importer;
+                    var asset = modelImporter.asset;
+
+                    // the model itself, not the node XML
+                    var model = <Atomic.Model> Atomic.cache.getResource("Model", asset.cachePath + ".mdl");
+
+                    if (model) {
+
+                        staticModel.model = model;
+                        ev.target.text = asset.name;
+
+                    }
+                }
+            }
+
+        });
+
+        // MATERIAL FIELD (single material, not multimaterial for now)
+
+        var materialField = InspectorUtils.createAttrEditField("Material", layout);
+        materialField.readOnly = true;
+
+        var material = staticModel.getMaterial();
+
+        if (material) {
+
+            materialField.text = material.name;
+
+        }
+
+        // handle dropping of material on field
+        materialField.subscribeToEvent(materialField, "DragEnded", (ev: Atomic.DragEndedEvent) => {
+
+            if (ev.target == materialField) {
+
+                var importer = this.acceptAssetDrag("MaterialImporter", ev);
+
+                if (importer) {
+
+                    var materialImporter = <ToolCore.MaterialImporter> importer;
+                    var asset = materialImporter.asset;
+
+                    var material = <Atomic.Material> Atomic.cache.getResource("Material", asset.path);
+
+                    if (material) {
+
+                        staticModel.material = material;
+                        ev.target.text = material.name;
+
+                    }
+                }
+            }
+
+        });
+
+
+    }
+
     addJSComponentUI(layout: Atomic.UILayout) {
 
         var js = <Atomic.JSComponent> this.component;
@@ -199,27 +307,21 @@ class ComponentInspector extends Atomic.UISection {
 
             if (ev.target == field) {
 
-                var dragObject = ev.dragObject;
-
-                if (dragObject.object && dragObject.object.typeName == "Asset") {
+                var importer = this.acceptAssetDrag("JavascriptImporter", ev);
 
-                    var asset = <ToolCore.Asset> dragObject.object;
+                if (importer) {
 
-                    if (asset.importerTypeName == "JavascriptImporter") {
+                    var jsImporter = <ToolCore.JavascriptImporter> importer;
 
-                        var jsImporter = <ToolCore.JavascriptImporter> asset.importer;
-                        if (jsImporter.isComponentFile()) {
+                    if (jsImporter.isComponentFile()) {
 
-                            js.componentFile = <Atomic.JSComponentFile> Atomic.cache.getResource("JSComponentFile", asset.path);
-                            if (js.componentFile)
-                                ev.target.text = js.componentFile.name;
-
-                        }
+                        js.componentFile = <Atomic.JSComponentFile> Atomic.cache.getResource("JSComponentFile", importer.asset.path);
+                        if (js.componentFile)
+                            ev.target.text = js.componentFile.name;
 
                     }
 
                 }
-
             }
 
         });

Script/AtomicEditor/ui/inspector/CreateComponentButton.ts

@@ -10,12 +10,12 @@ audioCreateSource.addItem(new Atomic.UIMenuItem("SoundSource3D", "create compone
 
 var geometryCreateSource = new Atomic.UIMenuItemSource();
 
+geometryCreateSource.addItem(new Atomic.UIMenuItem("StaticModel", "StaticModel"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("AnimatedModel", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("BillboardSet", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("CustomGeometry", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("ParticleEmitter", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("Skybox", "create component"));
-geometryCreateSource.addItem(new Atomic.UIMenuItem("StaticModel", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("StaticModelGroup", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("Terrain", "create component"));
 geometryCreateSource.addItem(new Atomic.UIMenuItem("Text3D", "create component"));
@@ -23,8 +23,8 @@ geometryCreateSource.addItem(new Atomic.UIMenuItem("Water", "create component"))
 
 var logicCreateSource = new Atomic.UIMenuItemSource();
 
+logicCreateSource.addItem(new Atomic.UIMenuItem("JSComponent", "JSComponent"));
 logicCreateSource.addItem(new Atomic.UIMenuItem("AnimationController", "create component"));
-logicCreateSource.addItem(new Atomic.UIMenuItem("Javascript Component", "JSComponent"));
 logicCreateSource.addItem(new Atomic.UIMenuItem("SplinePath", "create component"));
 
 var navigationCreateSource = new Atomic.UIMenuItemSource();

Script/TypeScript/ToolCore.d.ts

@@ -276,6 +276,7 @@ declare module ToolCore {
 
       getAssetByGUID(guid: string): Asset;
       getAssetByPath(path: string): Asset;
+      getAssetByCachePath(cachePath: string): Asset;
       generateAssetGUID(): string;
       registerGUID(guid: string): void;
       getCachePath(): string;
@@ -289,6 +290,8 @@ declare module ToolCore {
 
    export class AssetImporter extends Atomic.AObject {
 
+      asset: Asset;
+
       // Construct.
       constructor(asset: Asset);
 
@@ -296,6 +299,7 @@ declare module ToolCore {
       // Imports to cached data
       import(guid: string): boolean;
       preload(): boolean;
+      getAsset(): Asset;
       requiresCacheFile(): boolean;
 
    }

Source/ToolCore/Assets/AssetDatabase.cpp

@@ -86,6 +86,24 @@ void AssetDatabase::Import(const String& path)
         return;
 }
 
+Asset* AssetDatabase::GetAssetByCachePath(const String& cachePath)
+{
+    List<SharedPtr<Asset>>::ConstIterator itr = assets_.Begin();
+
+    String cacheFilename = GetFileName(cachePath);
+
+    while (itr != assets_.End())
+    {
+        if ((*itr)->GetCachePath().Contains(cacheFilename))
+            return *itr;
+
+        itr++;
+    }
+
+    return 0;
+
+}
+
 Asset* AssetDatabase::GetAssetByGUID(const String& guid)
 {
     List<SharedPtr<Asset>>::ConstIterator itr = assets_.Begin();

Source/ToolCore/Assets/AssetDatabase.h

@@ -23,6 +23,7 @@ public:
 
     Asset* GetAssetByGUID(const String& guid);
     Asset* GetAssetByPath(const String& path);
+    Asset* GetAssetByCachePath(const String& cachePath);
 
     String GenerateAssetGUID();
     void RegisterGUID(const String& guid);

Source/ToolCore/Assets/AssetImporter.h

@@ -32,6 +32,8 @@ public:
     virtual bool Import(const String& guid) = 0;
     virtual bool Preload() { return true; }
 
+    Asset* GetAsset() { return asset_; }
+
     bool RequiresCacheFile() const { return requiresCacheFile_; }
 
 protected: