Saving and loading of new sprites in the entity editor, cloning of new sprites, added a random starting frame parameter to new sprites

Core/Contents/Include/PolySceneSprite.h

@@ -102,10 +102,12 @@ namespace Polycode {
         
         unsigned int getNumStates();
         SpriteState *getState(unsigned int index);
+        SpriteState *getStateByName(const String &name);
         
         void setParentSpritSet(SpriteSet *spriteSet);
         SpriteSet *getParentSpriteSet();
         
+        
     protected:
         String name;
         SpriteSet *parentSpriteSet;
@@ -144,6 +146,8 @@ namespace Polycode {
         void createGridFrames(Number width, Number height, const Vector2 &defaultAnchor);
         void createFramesFromIslands(unsigned int minDistance, const Vector2 &defaultAnchor);
         
+        Sprite *getSpriteByName(String spriteName);
+        
     protected:
         
         unsigned int nextFrameIDIndex;
@@ -157,9 +161,16 @@ namespace Polycode {
         SceneSprite(SpriteSet *spriteSet);
         ~SceneSprite();
         
+        Entity *Clone(bool deepClone, bool ignoreEditorOnly) const;
+        void applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const;
+        
         SpriteSet *getSpriteSet();
         Sprite *getCurrentSprite();
         
+        void setSpriteSet(SpriteSet *spriteSet);
+        
+        void setSpriteByName(String spriteName);
+        
         void setCurrentFrame(unsigned int frameIndex);
         unsigned int getCurrentFrame();
         void Update();
@@ -169,12 +180,21 @@ namespace Polycode {
         bool isPaused();
         
         void setSprite(Sprite *spriteEntry);
-        void setSpriteState(SpriteState *spriteState);
+        
+        void setSpriteState(SpriteState *spriteState, unsigned int startingFrame, bool playOnce);
+        
+        void setSpriteStateByName(String name, unsigned int startingFrame, bool playOnce);
+        
         SpriteState *getCurrentSpriteState();
         
+
+        bool getStartOnRandomFrame();
+        void setStartOnRandomFrame(bool val);
         
     protected:
         
+        bool startOnRandomFrame;
+        bool playOnce;
         bool paused;
         Core *core;
         unsigned int currentFrame;

Core/Contents/Source/PolySceneEntityInstance.cpp

@@ -285,17 +285,38 @@ Entity *SceneEntityInstance::loadObjectEntryIntoEntity(ObjectEntry *entry, Entit
             SceneEntityInstance *instance = new SceneEntityInstance(parentScene, filePath);
             entity = instance;
          } else if(entityType->stringVal == "SceneSprite") {
-             /*
+
 			ObjectEntry *spriteEntry = (*entry)["SceneSprite"];
-			String filePath = (*spriteEntry)["filePath"]->stringVal;
-			
-			SceneSprite *sprite = new SceneSprite(filePath);
-			
-			String animName = (*spriteEntry)["anim"]->stringVal;
-			sprite->playAnimation(animName, -1, false);
-			entity = sprite;
-            applySceneMesh((*entry)["SceneMesh"], sprite);
-              */
+			String spriteSetName = (*spriteEntry)["sprite_set"]->stringVal;
+
+             SpriteSet *spriteSet = (SpriteSet*)CoreServices::getInstance()->getResourceManager()->getResourcePoolByName(spriteSetName);
+             
+             if(spriteSet) {
+                 SceneSprite *sprite = new SceneSprite(spriteSet);
+                 
+                 String spriteName = (*spriteEntry)["sprite"]->stringVal;
+                 sprite->setSpriteByName(spriteName);
+
+                 
+                 String stateName = (*spriteEntry)["state"]->stringVal;
+                 
+                 if(sprite->getCurrentSprite()) {
+                     SpriteState *state = sprite->getCurrentSprite()->getStateByName(stateName);
+                     if(state) {
+                         sprite->setSpriteState(state, 0, false);
+                     }
+                     
+                     ObjectEntry *randomFrameEntry = (*spriteEntry)["random_frame"];
+                     if(randomFrameEntry) {
+                        sprite->setStartOnRandomFrame(randomFrameEntry->boolVal);
+                     }
+                     
+                 }
+                 
+                 entity = sprite;
+                 applySceneMesh((*entry)["SceneMesh"], sprite);
+             }
+
         } else 	if(entityType->stringVal == "SceneLabel") {
 			ObjectEntry *labelEntry = (*entry)["SceneLabel"];
 			

Core/Contents/Source/PolySceneSprite.cpp

@@ -34,16 +34,44 @@ using namespace Polycode;
 SceneSprite::SceneSprite(SpriteSet *spriteSet) : SceneMesh(Mesh::QUAD_MESH) {
     currentSprite = NULL;
     currentSpriteState = NULL;
-    this->spriteSet = spriteSet;
+    setSpriteSet(spriteSet);
     defaultMesh = mesh;
     currentFrame = 0;
     core = Services()->getCore();
     spriteTimer = 0.0;
     paused = false;
+    playOnce = false;
     spriteTimerVal = 0.1;
-    setTexture(spriteSet->getTexture());
+    useGeometryHitDetection = false;
+    ownsMesh = false;
+    startOnRandomFrame = false;
+}
+
+bool SceneSprite::getStartOnRandomFrame() {
+    return startOnRandomFrame;
+}
+
+void SceneSprite::setStartOnRandomFrame(bool val) {
+    startOnRandomFrame = val;
+    if(val && currentSpriteState) {
+        currentFrame = rand() % currentSpriteState->getNumFrameIDs();
+    }
+}
+
+Entity *SceneSprite::Clone(bool deepClone, bool ignoreEditorOnly) const {
+    SceneSprite *newSprite = new SceneSprite(spriteSet);
+    newSprite->setSprite(currentSprite);
+    newSprite->setSpriteState(currentSpriteState, currentFrame, playOnce);
+    newSprite->setStartOnRandomFrame(startOnRandomFrame);
+    applyClone(newSprite, deepClone, ignoreEditorOnly);
+    return newSprite;
+}
+
+void SceneSprite::applyClone(Entity *clone, bool deepClone, bool ignoreEditorOnly) const {
+    SceneMesh::applyClone(clone, deepClone, ignoreEditorOnly);
 }
 
+
 SpriteState *SceneSprite::getCurrentSpriteState() {
     return currentSpriteState;
 }
@@ -68,17 +96,48 @@ void SceneSprite::setCurrentFrame(unsigned int frameIndex) {
     currentFrame = frameIndex;
 }
 
+void SceneSprite::setSpriteByName(String spriteName) {
+    Sprite *sprite = spriteSet->getSpriteByName(spriteName);
+    if(sprite) {
+        setSprite(sprite);
+    }
+}
+
 void SceneSprite::setSprite(Sprite *spriteEntry) {
+    if(spriteEntry->getParentSpriteSet() != spriteSet) {
+        setSpriteSet(spriteEntry->getParentSpriteSet());
+    }
     currentSprite = spriteEntry;
+    currentSpriteState = NULL;
+}
+
+void SceneSprite::setSpriteSet(SpriteSet *spriteSet) {
+    this->spriteSet = spriteSet;
+    setTexture(spriteSet->getTexture());
+    currentSprite = NULL;
+    currentSpriteState = NULL;
+}
+
+void SceneSprite::setSpriteStateByName(String name, unsigned int startingFrame, bool playOnce) {
+    if(!currentSprite) {
+        return;
+    }
+    SpriteState *spriteState = currentSprite->getStateByName(name);
+    if(spriteState) {
+        setSpriteState(spriteState, startingFrame, playOnce);
+    }
 }
 
-void SceneSprite::setSpriteState(SpriteState *spriteState) {
+void SceneSprite::setSpriteState(SpriteState *spriteState, unsigned int startingFrame, bool playOnce) {
     currentSpriteState = spriteState;
     
     if(!currentSpriteState) {
         return;
     }
     
+    this->playOnce = playOnce;
+    currentFrame = startingFrame;
+    
     Vector2 bBox = spriteState->getBoundingBox();
     setLocalBoundingBox(bBox.x / spriteState->getPixelsPerUnit(), bBox.y / spriteState->getPixelsPerUnit(), 0.001);
 }
@@ -101,7 +160,11 @@ void SceneSprite::Update() {
         spriteTimer = 0.0;
         currentFrame++;
         if(currentFrame >= currentSpriteState->getNumFrameIDs()) {
-            currentFrame = 0;
+            if(playOnce) {
+                currentFrame = currentSpriteState->getNumFrameIDs()-1;
+            } else {
+                currentFrame = 0;
+            }
         }
     }
 }
@@ -118,9 +181,11 @@ void SceneSprite::Render() {
     
     Mesh *stateMesh = currentSpriteState->getMeshForFrameIndex(currentFrame);
     if(stateMesh) {
-        setMesh(stateMesh);
+        this->mesh = stateMesh;
+        useVertexBuffer = false;
     } else {
-        setMesh(defaultMesh);
+        this->mesh = defaultMesh;
+        useVertexBuffer = false;
     }
     
     SceneMesh::Render();
@@ -307,6 +372,15 @@ SpriteState *Sprite::getState(unsigned int index) {
     }
 }
 
+SpriteState *Sprite::getStateByName(const String &name) {
+    for(int i=0; i < states.size(); i++) {
+        if(states[i]->getName() == name) {
+            return states[i];
+        }
+    }
+    return NULL;
+}
+
 void Sprite::addSpriteState(SpriteState *state) {
     states.push_back(state);
 }
@@ -509,6 +583,15 @@ void SpriteSet::removeSprite(Sprite *sprite) {
     }
 }
 
+Sprite *SpriteSet::getSpriteByName(String spriteName) {
+    for(int i=0; i < sprites.size(); i++) {
+        if(sprites[i]->getName() == spriteName) {
+            return sprites[i];
+        }
+    }
+    return NULL;
+}
+
 Texture *SpriteSet::loadTexture(String imageFileName) {
     Texture *spriteTexture = Services()->getMaterialManager()->createTextureFromFile(imageFileName, true, Services()->getMaterialManager()->mipmapsDefault);
     setTexture(spriteTexture);

IDE/Contents/Include/EntityEditorPropertyView.h

@@ -56,7 +56,7 @@ class EntityEditorPropertyView : public UIElement {
         SceneLightSheet *lightSheet;
         ParticleEmitterSheet *particleSheet;
         SceneLabelSheet *labelSheet;
-    //    SceneSpriteSheet *spriteSheet;
+        SceneSpriteSheet *spriteSheet;
         SoundSheet *soundSheet;
         CameraSheet *cameraSheet;
         EntityPropSheet *propSheet;

IDE/Contents/Include/PolycodeProps.h

@@ -427,7 +427,7 @@ class TextureProp : public PropProp {
 		String lastData;
 		String currentData;
 };
-/*
+
 class SceneSpriteProp : public PropProp {
 	public:
 		SceneSpriteProp(String caption);
@@ -436,16 +436,21 @@ class SceneSpriteProp : public PropProp {
 		
 		void setPropData(PolycodeEditorPropActionData* data);
 		
-		void set(String fileName);
-		String get();		
+        void setEntityInstance(SceneEntityInstance *instance);
+    
+		void set(Sprite *sprite);
+		Sprite *get();
 				
+        SceneEntityInstance *entityInstance;
+    
+        Sprite *sprite;
 		SceneSprite *previewSprite;
 		UIButton *changeButton;
-		
-		String lastData;
-		String currentData;
+        UILabel *spriteName;
+    
+        Sprite *lastData;
+		Sprite *currentData;
 };
-*/
 
 class SceneEntityInstanceProp : public PropProp {
 	public:
@@ -806,7 +811,7 @@ class SceneLabelSheet : public PropSheet {
 		ComboProp *font;
 		BoolProp *enableAA;
 };
-/*
+
 class SceneSpriteSheet : public PropSheet {
 	public:
 		SceneSpriteSheet();
@@ -814,14 +819,16 @@ class SceneSpriteSheet : public PropSheet {
 		
 		void handleEvent(Event *event);
         void setSprite(SceneSprite *sprite);
+    
+        void setEntityInstance(SceneEntityInstance *instance);
 				
-		SceneSprite *sprite;	
-		SceneSpriteProp *spriteProp;
-        ComboProp *defaultAnimationProp;
-        NumberProp *spriteWidthProp;
-        NumberProp *spriteHeightProp;
+		SceneSprite *sprite;
+    
+        SceneSpriteProp *spriteProp;
+        BoolProp *randomFrameProp;
+        ComboProp *defaultStateProp;
 };
-*/
+
 
 class CameraSheet : public PropSheet {
     public:

IDE/Contents/Source/EntityEditorPropertyView.cpp

@@ -59,11 +59,11 @@ EntityEditorPropertyView::EntityEditorPropertyView() : UIElement() {
     particleSheet = new ParticleEmitterSheet();
     entityProps->addPropSheet(particleSheet);
     particleSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
-  /*
+
     spriteSheet = new SceneSpriteSheet();
     entityProps->addPropSheet(spriteSheet);
     spriteSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
-    */
+
     primitiveSheet = new ScenePrimitiveSheet();
     entityProps->addPropSheet(primitiveSheet);
     primitiveSheet->addEventListener(this, PropEvent::EVENT_PROP_CHANGE);
@@ -89,6 +89,7 @@ EntityEditorPropertyView::EntityEditorPropertyView() : UIElement() {
 void EntityEditorPropertyView::setEntityInstance(SceneEntityInstance *instance) {
     materialSheet->setEntityInstance(instance);
     entitySheet->setEntityInstance(instance);
+    spriteSheet->setEntityInstance(instance);
 }
 
 void EntityEditorPropertyView::Resize(Number width, Number height) {
@@ -149,7 +150,7 @@ void EntityEditorPropertyView::setEntity(Entity *entity) {
     labelSheet->setSceneLabel(sceneLabel);
 
     SceneSprite *sceneSprite = dynamic_cast<SceneSprite*>(entity);
-//    spriteSheet->setSprite(sceneSprite);
+    spriteSheet->setSprite(sceneSprite);
 
     ScenePrimitive *scenePrimitive = dynamic_cast<ScenePrimitive*>(entity);
     

IDE/Contents/Source/PolycodeEntityEditor.cpp

@@ -764,8 +764,9 @@ void EntityEditorMainView::setEditorProps(Entity *entity) {
     
     SceneMesh *sceneMesh = dynamic_cast<SceneMesh*>(entity);
     SceneParticleEmitter *emitter = dynamic_cast<SceneParticleEmitter*>(entity);
+    SceneSprite *sprite = dynamic_cast<SceneSprite*>(entity);
     
-    if(sceneMesh && !emitter) {
+    if(sceneMesh && !emitter && !sprite) {
         sceneMesh->wireFrameColor = Color(1.0, 0.8, 0.3, 1.0);
 //        sceneMesh->setLineWidth(CoreServices::getInstance()->getRenderer()->getBackingResolutionScaleX());
         sceneMesh->useGeometryHitDetection = true;
@@ -1140,7 +1141,7 @@ void EntityEditorMainView::handleEvent(Event *event) {
                     SceneSprite *newSprite = new SceneSprite(sprite->getParentSpriteSet());
                     newSprite->setSprite(sprite);
                     if(sprite->getNumStates() > 0) {
-                        newSprite->setSpriteState(sprite->getState(0));
+                        newSprite->setSpriteState(sprite->getState(0), 0, false);
                     }
                     
                     newSprite->setMaterialByName("Unlit");
@@ -1824,20 +1825,23 @@ void PolycodeEntityEditor::saveEntityToObjectEntry(Entity *entity, ObjectEntry *
     }
     
     if(dynamic_cast<SceneSprite*>(entity)) {
-        /*
+
         if(!(*(entry))["type"])
             entry->addChild("type", "SceneSprite");
         SceneSprite *sprite = (SceneSprite*) entity;
         
         ObjectEntry *spriteEntry = entry->addChild("SceneSprite");
-        spriteEntry->addChild("filePath", sprite->getFileName());
+        
+        spriteEntry->addChild("sprite_set", sprite->getSpriteSet()->getName());
+        spriteEntry->addChild("sprite", sprite->getCurrentSprite()->getName());
+        spriteEntry->addChild("random_frame", sprite->getStartOnRandomFrame());
         
         String animName = "";
-        if(sprite->getCurrentAnimation()) {
-            animName = sprite->getCurrentAnimation()->name;
+        if(sprite->getCurrentSpriteState()) {
+            animName = sprite->getCurrentSpriteState()->getName();
         }
-        spriteEntry->addChild("anim", animName);
-        */
+        spriteEntry->addChild("state", animName);
+
     }
     
     if(dynamic_cast<SceneLabel*>(entity)) {

IDE/Contents/Source/PolycodeProps.cpp

@@ -1388,78 +1388,118 @@ void TextureProp::set(Texture *texture) {
 Texture* TextureProp::get() {
 	return previewShape->getTexture();
 }
-/*
-SceneSpriteProp::SceneSpriteProp(String caption) : PropProp(caption, "SceneSprite"){
 
-		previewSprite = new SceneSprite("default/default.sprite");
-        previewSprite->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
-		previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
-		previewSprite->setPosition(2, 1);
-		previewSprite->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, 48,48);		
-		propContents->addChild(previewSprite);	
+SceneSpriteProp::SceneSpriteProp(String caption) : PropProp(caption, "SceneSprite"){
 
-	
+	previewSprite = NULL;
+    
 	changeButton = new UIButton("Change", 80);
 	propContents->addChild(changeButton);
 	changeButton->setPosition(60, 5);
 	changeButton->addEventListener(this, UIEvent::CLICK_EVENT);
-	setHeight(70);
+	setHeight(55);
+    
+	spriteName = new UILabel("", 12, "sans");
+	propContents->addChild(spriteName);
+	spriteName->setPosition(-100, 32);
+	spriteName->color.a = 1.0;
+    
 }
 
 SceneSpriteProp::~SceneSpriteProp() {
 
 }
 
+void SceneSpriteProp::setEntityInstance(SceneEntityInstance *instance) {
+    entityInstance = instance;
+}
+
 void SceneSpriteProp::handleEvent(Event *event) {
 
 	if(event->getDispatcher() == globalFrame->assetBrowser && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::OK_EVENT) {
-		String filePath = globalFrame->assetBrowser->getSelectedAssetPath();
-		
-		set(filePath);
-		
-		globalFrame->assetBrowser->removeAllHandlersForListener(this);
-		dispatchEvent(new Event(), Event::CHANGE_EVENT);
-		dispatchEvent(new PropEvent(this, NULL, PropDataString(lastData), PropDataString(currentData)), PropEvent::EVENT_PROP_CHANGE);
-		globalFrame->hideModal();
+        
+        Resource *selectedResource = globalFrame->assetBrowser->getSelectedResource();
+        
+        if(selectedResource) {
+            sprite = (Sprite*) selectedResource;
+            previewSprite->setSprite(sprite);
+            
+            if(sprite->getNumStates() > 0) {
+                previewSprite->setSpriteState(sprite->getState(0), 0, false);
+            }
+            
+            Number spriteScale = 1.0;
+            if(previewSprite->getHeight() > previewSprite->getWidth()) {
+                spriteScale = 40.0 / previewSprite->getHeight();
+            } else {
+                spriteScale = 40.0 / previewSprite->getWidth();
+            }
+            previewSprite->setScale(spriteScale, spriteScale, 1.0);
+            
+            dispatchEvent(new Event(), Event::CHANGE_EVENT);
+//            dispatchEvent(new PropEvent(this, NULL, PropDataString(lastData), PropDataString(currentData)), PropEvent::EVENT_PROP_CHANGE);
+        }
+        globalFrame->assetBrowser->removeAllHandlersForListener(this);
+        globalFrame->hideModal();
+        
+        
 	}
 
 	if(event->getDispatcher() == changeButton && event->getEventType() == "UIEvent" && event->getEventCode() == UIEvent::CLICK_EVENT) {
-		globalFrame->assetBrowser->addEventListener(this, UIEvent::OK_EVENT);
-		
-		std::vector<String> extensions;
-		extensions.push_back("sprite");
-		globalFrame->showAssetBrowser(extensions);
+        
+        globalFrame->assetBrowser->addEventListener(this, UIEvent::OK_EVENT);
+		std::vector<ResourcePool*> pools;
+        pools.push_back(CoreServices::getInstance()->getResourceManager()->getGlobalPool());
+        for(int i=0; i < entityInstance->getNumLinkedResourePools(); i++) {
+            pools.push_back(entityInstance->getLinkedResourcePoolAtIndex(i));
+        }
+		globalFrame->showAssetBrowserForPools(pools, Resource::RESOURCE_SPRITE);
+        
 	}
 }
 
 void SceneSpriteProp::setPropData(PolycodeEditorPropActionData* data) {
-	set(data->stringVal);
-	dispatchEvent(new Event(), Event::CHANGE_EVENT);	
+//    set(data->stringVal);
+//	dispatchEvent(new Event(), Event::CHANGE_EVENT);
 }
 
-void SceneSpriteProp::set(String fileName) {
+void SceneSpriteProp::set(Sprite *sprite) {
 
-	if(fileName != previewSprite->getFileName()) {
-		if(previewSprite) {
-			propContents->removeChild(previewSprite);
-			delete previewSprite;
-		}
-		lastData = currentData;
-		currentData = fileName;
+    this->sprite = sprite;
+    
+    spriteName->setText(sprite->getName());
+
+    if(previewSprite) {
+        propContents->removeChild(previewSprite);
+        delete previewSprite;
+    }
+
+    lastData = currentData;
+    currentData = sprite;
 		
-		previewSprite = new SceneSprite(fileName);
-		previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
-		previewSprite->setPosition(2, 1);
-        previewSprite->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
-		previewSprite->setPrimitiveOptions(ScenePrimitive::TYPE_VPLANE, 48,48);		
-		propContents->addChild(previewSprite);	
-	}
+    previewSprite = new SceneSprite(sprite->getParentSpriteSet());
+    previewSprite->setSprite(sprite);
+    if(sprite->getNumStates() > 0) {
+        previewSprite->setSpriteState(sprite->getState(0), 0, false);
+    }
+    previewSprite->setAnchorPoint(-1.0, -1.0, 0.0);
+    previewSprite->setPosition(2, 1);
+    previewSprite->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
+    propContents->addChild(previewSprite);
+    
+    Number spriteScale = 1.0;
+    if(previewSprite->getHeight() > previewSprite->getWidth()) {
+        spriteScale = 40.0 / previewSprite->getHeight();
+    } else {
+        spriteScale = 40.0 / previewSprite->getWidth();
+    }
+    previewSprite->setScale(spriteScale, spriteScale, 1.0);
 }
 
-String SceneSpriteProp::get() {
-	return previewSprite->getFileName();
+Sprite *SceneSpriteProp::get() {
+	return sprite;
 }
-*/
+
 SceneEntityInstanceProp::SceneEntityInstanceProp(String caption) : PropProp(caption, "SceneEntityInstance"){
 //	previewInstance = new SceneEntityInstance("default/default.entity");
 	previewInstance->setAnchorPoint(-1.0, -1.0, 0.0);
@@ -3360,68 +3400,68 @@ void CameraSheet::setCamera(Camera *camera) {
     }
 }
 
-/*
+
 SceneSpriteSheet::SceneSpriteSheet() : PropSheet("SPRITE", "SceneSprite") {
 	sprite = NULL;
     enabled = false;
 	
-	spriteProp = new SceneSpriteProp("Sprite");
-	spriteProp->addEventListener(this, Event::CHANGE_EVENT);
-	addProp(spriteProp);	
+    spriteProp = new SceneSpriteProp("Sprite");
+    spriteProp->addEventListener(this, Event::CHANGE_EVENT);
+    addProp(spriteProp);
 	
-	defaultAnimationProp = new ComboProp("Animation");
-	defaultAnimationProp->addEventListener(this, Event::CHANGE_EVENT);
-	addProp(defaultAnimationProp);
-    
-    spriteWidthProp = new NumberProp("Width");
-	spriteWidthProp->addEventListener(this, Event::CHANGE_EVENT);
-	addProp(spriteWidthProp);
-
-    spriteHeightProp = new NumberProp("Height");
-	spriteHeightProp->addEventListener(this, Event::CHANGE_EVENT);
-	addProp(spriteHeightProp);
+	defaultStateProp = new ComboProp("State");
+	defaultStateProp->addEventListener(this, Event::CHANGE_EVENT);
+	addProp(defaultStateProp);
 
+    randomFrameProp = new BoolProp("Random start frame");
+    randomFrameProp->addEventListener(this, Event::CHANGE_EVENT);
+    addProp(randomFrameProp);
+    
 	propHeight = 190;
 }
 
 SceneSpriteSheet::~SceneSpriteSheet() {
 
 }
-		
+
+void SceneSpriteSheet::setEntityInstance(SceneEntityInstance *instance) {
+    spriteProp->setEntityInstance(instance);
+}
+
 void SceneSpriteSheet::handleEvent(Event *event) {
 	if(!sprite)
 		return;
 
-	if(event->getDispatcher() == sprite->getResourceEntry()) {
-		spriteProp->previewSprite->reloadSprite();
-		sprite->getResourceEntry()->removeAllHandlersForListener(this);
-	}
-
-    if(event->getDispatcher() == spriteWidthProp) {
-        sprite->setActualSpriteSize(spriteWidthProp->get(), sprite->getActualSpriteSize().y);
-        dispatchEvent(new Event(), Event::CHANGE_EVENT);
+	if(event->getDispatcher() == defaultStateProp) {
+		sprite->setSpriteStateByName(defaultStateProp->comboEntry->getSelectedItem()->label, 0, false);
+            spriteProp->previewSprite->setSpriteStateByName(defaultStateProp->comboEntry->getSelectedItem()->label, 0, false);
 	}
 
-    if(event->getDispatcher() == spriteHeightProp) {
-        sprite->setActualSpriteSize(sprite->getActualSpriteSize().x, spriteHeightProp->get());
-        dispatchEvent(new Event(), Event::CHANGE_EVENT);
-	}
- 
+	if(event->getDispatcher() == randomFrameProp) {
+        sprite->setStartOnRandomFrame(randomFrameProp->get());
+    }
     
-	if(event->getDispatcher() == defaultAnimationProp) {
-		sprite->playAnimation(defaultAnimationProp->comboEntry->getSelectedItem()->label, 0, false);
-		spriteProp->previewSprite->playAnimation(defaultAnimationProp->comboEntry->getSelectedItem()->label, 0, false);
-	}
-
 	if(event->getDispatcher() == spriteProp) {
-		sprite->loadFromFile(spriteProp->get());
-			defaultAnimationProp->comboEntry->clearItems();
-			for(int i=0; i < sprite->getNumAnimations(); i++) {
-				defaultAnimationProp->comboEntry->addComboItem(sprite->getAnimationAtIndex(i)->name);
-			}
-		
+        sprite->setSprite(spriteProp->get());
+        defaultStateProp->comboEntry->clearItems();
+        
+        if(spriteProp->get()->getNumStates() > 0) {
+            sprite->setSpriteState(spriteProp->get()->getState(0), 0, false);
+        }
+
+        Sprite *spriteEntry = sprite->getCurrentSprite();
+        for(int i=0; i < spriteEntry->getNumStates(); i++) {
+            defaultStateProp->comboEntry->addComboItem(spriteEntry->getState(i)->getName());
+            
+            if(sprite->getCurrentSpriteState()) {
+                if(sprite->getCurrentSpriteState() == spriteEntry->getState(i)) {
+                    defaultStateProp->comboEntry->setSelectedIndex(i);
+                    //spriteProp->previewSprite->setSpriteStateByName(defaultStateProp->comboEntry->getSelectedItem()->label, 0, false);
+                }
+            }
+        }
 	}
-	
+
 	PropSheet::handleEvent(event);
 }
 
@@ -3429,28 +3469,27 @@ void SceneSpriteSheet::setSprite(SceneSprite *sprite) {
     this->sprite = sprite;
     
 	if(sprite) {
-			defaultAnimationProp->comboEntry->clearItems();
-			for(int i=0; i < sprite->getNumAnimations(); i++) {
-				defaultAnimationProp->comboEntry->addComboItem(sprite->getAnimationAtIndex(i)->name);
-				if(sprite->getCurrentAnimation()) {
-					if(sprite->getCurrentAnimation()->name == sprite->getAnimationAtIndex(i)->name) {
-						defaultAnimationProp->comboEntry->setSelectedIndex(i);
-						spriteProp->previewSprite->playAnimation(sprite->getCurrentAnimation()->name, 0, false);
+            spriteProp->set(sprite->getCurrentSprite());
+			defaultStateProp->comboEntry->clearItems();
+        
+            Sprite *spriteEntry = sprite->getCurrentSprite();
+			for(int i=0; i < spriteEntry->getNumStates(); i++) {
+				defaultStateProp->comboEntry->addComboItem(spriteEntry->getState(i)->getName());
+                
+				if(sprite->getCurrentSpriteState()) {
+					if(sprite->getCurrentSpriteState() == spriteEntry->getState(i)) {
+						defaultStateProp->comboEntry->setSelectedIndex(i);
+						//spriteProp->previewSprite->setSpriteStateByName(defaultStateProp->comboEntry->getSelectedItem()->label, 0, false);
 					}
 				}
 			}
+            randomFrameProp->set(sprite->getStartOnRandomFrame());
 
-		enabled = true;	
-		spriteProp->set(sprite->getFileName());
-		sprite->getResourceEntry()->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
-        
-        spriteWidthProp->set(sprite->getActualSpriteSize().x);
-        spriteHeightProp->set(sprite->getActualSpriteSize().y);
+		enabled = true;
 	} else {
 		enabled = false;
 	}
 }
-*/
 
 SceneEntityInstanceSheet::SceneEntityInstanceSheet() : PropSheet("ENTITY INSTANCE", "SceneEntityInstance") {
 	instance = NULL;

IDE/Contents/Source/PolycodeSpriteEditor.cpp

@@ -1907,7 +1907,7 @@ void PolycodeSpriteEditor::handleEvent(Event *event) {
     
         
     } else if(event->getDispatcher() == stateEditor) {
-        spritePreview->getSceneSprite()->setSpriteState(stateEditor->getSelectedState());
+        spritePreview->getSceneSprite()->setSpriteState(stateEditor->getSelectedState(), 0, false);
     } else if(event->getDispatcher() == spriteSheetEditor) {
         SpriteState *state = spritePreview->getSceneSprite()->getCurrentSpriteState();
         if(state) {

IDE/Contents/Source/TextureBrowser.cpp

@@ -218,7 +218,6 @@ void AssetList::handleEvent(Event *event) {
 			if(event->getDispatcher() == assetEntries[i]->selectShape && event->getEventCode() == InputEvent::EVENT_MOUSEDOWN) {
 				assetEntries[i]->selectShape->visible = true;
 				selectedPath = assetEntries[i]->assetPath;
-				printf("%s\n", selectedPath.c_str());
 				if(currentEntry) {
 					currentEntry->selectShape->visible = false;
 				}
@@ -275,6 +274,10 @@ AssetBrowser::AssetBrowser() : UIWindow(L"Asset Browser", 850, 500) {
 
 void AssetBrowser::setResourcePools(std::vector<ResourcePool*> pools, int resourceFilter) {
     
+    if(this->resourceFilter != resourceFilter) {
+        assetList->clearList();
+    }
+    
     this->resourceFilter = resourceFilter;
     
 	templateContainer->getRootNode()->clearTree();