Groundwork for character editor menu

assets/Data/creatures/human.json

@@ -59,7 +59,16 @@
                 "INVENTORY",
                 "OUTLINE"
             ],
-            "visualAttributes" : [],
+            "visualAttributes" : [
+                {
+                    "attributeId" : "TorsoHeight",
+                    "type" : "bone",
+                    "subtype" : "scalez",
+                    "primaryBone" : "Bone",
+                    "minValue" : 0.8,
+                    "maxValue" : 1.2
+                }
+            ],
             "movementSystems" : [
                 {
                     "type" : "GROUND",
@@ -262,7 +271,7 @@
                 "maxHealth" : 100,
                 "onDamageIFrames" : 30
             },
-            "modelPath" : "Models/baseman4.fbx"
+            "modelPath" : "Models/baseman5.fbx"
         }
     ],
     "files" : []

src/main/java/electrosphere/controls/ControlHandler.java

@@ -25,7 +25,9 @@ import electrosphere.menu.MenuGenerators;
 import electrosphere.renderer.ui.Window;
 import electrosphere.renderer.ui.events.ClickEvent;
 import electrosphere.renderer.ui.events.KeyboardEvent;
+import electrosphere.renderer.ui.events.MenuEvent;
 import electrosphere.renderer.ui.events.MouseEvent;
+import electrosphere.renderer.ui.events.MenuEvent.MenuEventType;
 
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -66,6 +68,8 @@ public class ControlHandler {
     public static final String INPUT_CODE_CHARACTER_OPEN = "characterOpen";
     public static final String INPUT_CODE_IRON_SIGHT = "ironSight";
     
+    public static final String DATA_STRING_INPUT_CODE_MENU_NAVIGATE_FORWARD = "menuNavigateForward";
+    public static final String DATA_STRING_INPUT_CODE_MENU_NAVIGATE_BACKWARDS = "menuNavigateBackwards";
     public static final String DATA_STRING_INPUT_CODE_MENU_INCREMENT = "menuIncrement";
     public static final String DATA_STRING_INPUT_CODE_MENU_DECREMENT = "menuDecrement";
     public static final String DATA_STRING_INPUT_CODE_MENU_SELECT = "menuSelect";
@@ -191,8 +195,10 @@ public class ControlHandler {
         /*
         Map the menu navigation controls
         */
-        handler.addControl(DATA_STRING_INPUT_CODE_MENU_INCREMENT, new Control(ControlType.KEY,GLFW_KEY_DOWN));
+        handler.addControl(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_FORWARD, new Control(ControlType.KEY,GLFW_KEY_DOWN));
-        handler.addControl(DATA_STRING_INPUT_CODE_MENU_DECREMENT, new Control(ControlType.KEY,GLFW_KEY_UP));
+        handler.addControl(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_BACKWARDS, new Control(ControlType.KEY,GLFW_KEY_UP));
+        handler.addControl(DATA_STRING_INPUT_CODE_MENU_INCREMENT, new Control(ControlType.KEY,GLFW_KEY_RIGHT));
+        handler.addControl(DATA_STRING_INPUT_CODE_MENU_DECREMENT, new Control(ControlType.KEY,GLFW_KEY_LEFT));
         handler.addControl(DATA_STRING_INPUT_CODE_MENU_SELECT, new Control(ControlType.KEY,GLFW_KEY_ENTER));
         handler.addControl(DATA_STRING_INPUT_CODE_MENU_BACKOUT, new Control(ControlType.KEY,GLFW_KEY_ESCAPE));
         handler.addControl(INPUT_CODE_MENU_MOUSE_PRIMARY, new Control(ControlType.MOUSE_BUTTON,GLFW_MOUSE_BUTTON_LEFT));
@@ -788,18 +794,62 @@ public class ControlHandler {
     }
     
     void setMenuNavigationControls(){
-        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT));
+        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_FORWARD));
-        controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT).setOnPress(new ControlMethod(){public void execute(){
+        controls.get(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_FORWARD).setOnPress(new ControlMethod(){public void execute(){
             // Globals.currentMenu.incrementMenuOption();
             Globals.elementManager.focusNextElement();
         }});
 
-        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT));
+        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_BACKWARDS));
-        controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT).setOnPress(new ControlMethod(){public void execute(){
+        controls.get(DATA_STRING_INPUT_CODE_MENU_NAVIGATE_BACKWARDS).setOnPress(new ControlMethod(){public void execute(){
             // Globals.currentMenu.decrementMenuOption();
             Globals.elementManager.focusPreviousElement();
         }});
 
+
+
+        //Incrementing a menu element
+        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT));
+        controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT).setOnPress(new ControlMethod(){public void execute(){
+            Globals.elementManager.fireEvent(
+                new MenuEvent(MenuEventType.INCREMENT),
+                Globals.elementManager.getFocusedElement().getPositionX(),
+                Globals.elementManager.getFocusedElement().getPositionY()
+            );
+        }});
+        controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT).setOnRepeat(new ControlMethod(){public void execute(){
+            Globals.elementManager.fireEvent(
+                new MenuEvent(MenuEventType.INCREMENT),
+                Globals.elementManager.getFocusedElement().getPositionX(),
+                Globals.elementManager.getFocusedElement().getPositionY()
+            );
+        }});
+        controls.get(DATA_STRING_INPUT_CODE_MENU_INCREMENT).setRepeatTimeout(0.5f * Main.targetFrameRate);
+
+
+
+
+        //Decrementing a menu element
+        menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT));
+        controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT).setOnPress(new ControlMethod(){public void execute(){
+            Globals.elementManager.fireEvent(
+                new MenuEvent(MenuEventType.DECREMENT),
+                Globals.elementManager.getFocusedElement().getPositionX(),
+                Globals.elementManager.getFocusedElement().getPositionY()
+            );
+        }});
+        controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT).setOnRepeat(new ControlMethod(){public void execute(){
+            Globals.elementManager.fireEvent(
+                new MenuEvent(MenuEventType.DECREMENT),
+                Globals.elementManager.getFocusedElement().getPositionX(),
+                Globals.elementManager.getFocusedElement().getPositionY()
+            );
+        }});
+        controls.get(DATA_STRING_INPUT_CODE_MENU_DECREMENT).setRepeatTimeout(0.5f * Main.targetFrameRate);
+
+
+
+
         menuNavigationControlList.add(controls.get(DATA_STRING_INPUT_CODE_MENU_SELECT));
         controls.get(DATA_STRING_INPUT_CODE_MENU_SELECT).setOnPress(new ControlMethod(){public void execute(){
             Globals.elementManager.click(new ClickEvent(

src/main/java/electrosphere/entity/types/creature/CreatureUtils.java

@@ -50,6 +50,7 @@ import electrosphere.net.server.player.Player;
 import electrosphere.renderer.Model;
 import electrosphere.renderer.actor.Actor;
 import electrosphere.renderer.actor.ActorBoneRotator;
+import electrosphere.renderer.actor.ActorStaticMorph;
 import electrosphere.renderer.actor.ActorUtils;
 import electrosphere.renderer.light.PointLight;
 import electrosphere.util.ModelLoader;
@@ -289,15 +290,30 @@ public class CreatureUtils {
         }
         //variants
         if(rawType.getVisualAttributes() != null){
+            ActorStaticMorph staticMorph = null;
             for(VisualAttribute attributeType : rawType.getVisualAttributes()){
-                if(attributeType.getVariants() != null && attributeType.getVariants().size() > 0){
+                if(attributeType.getType().equals("remesh")){
-                    AttributeVariant variant = attributeType.getVariants().get(0);
+                    if(attributeType.getVariants() != null && attributeType.getVariants().size() > 0){
-                    // attributeType.getAttributeId();
+                        AttributeVariant variant = attributeType.getVariants().get(0);
-                    // variant.getId();
+                        // attributeType.getAttributeId();
-                    rVal.putData(EntityDataStrings.CREATURE_ATTRIBUTE_VARIANT + attributeType.getAttributeId(), variant.getId());
+                        // variant.getId();
-                    Globals.assetManager.addModelPathToQueue(variant.getModel());
+                        rVal.putData(EntityDataStrings.CREATURE_ATTRIBUTE_VARIANT + attributeType.getAttributeId(), variant.getId());
-                    for(String mesh : variant.getMeshes()){
+                        Globals.assetManager.addModelPathToQueue(variant.getModel());
-                        creatureActor.getMeshMask().queueMesh(variant.getModel(), mesh);
+                        for(String mesh : variant.getMeshes()){
+                            creatureActor.getMeshMask().queueMesh(variant.getModel(), mesh);
+                        }
+                    }
+                }
+                if(attributeType.getType().equals("bone")){
+                    if(staticMorph == null){
+                        staticMorph = new ActorStaticMorph();
+                        creatureActor.setActorStaticMorph(staticMorph);
+                    }
+                    if(attributeType.getPrimaryBone() != null && staticMorph.getBoneTransforms(attributeType.getPrimaryBone()) == null){
+                        staticMorph.initBoneTransforms(attributeType.getPrimaryBone());
+                    }
+                    if(attributeType.getMirrorBone() != null && staticMorph.getBoneTransforms(attributeType.getMirrorBone()) == null){
+                        staticMorph.initBoneTransforms(attributeType.getMirrorBone());
                     }
                 }
             }

src/main/java/electrosphere/game/data/creature/type/visualattribute/VisualAttribute.java

@@ -3,13 +3,46 @@ package electrosphere.game.data.creature.type.visualattribute;
 import java.util.List;
 
 public class VisualAttribute {
+
+
     String attributeId;
+    String type; //remesh or bone
+    String subtype; //if bone: yaw,pitch,roll,scalex,scaley,scalez,offx,offy,offz,offl
+    //offl = length offset, scaling along the offset from the previous bone (as if to elongate a limb)
     List<AttributeVariant> variants;
+    float minValue;
+    float maxValue;
+    String primaryBone;
+    String mirrorBone;
 
     public String getAttributeId(){
         return attributeId;
     }
 
+    public String getType(){
+        return type;
+    }
+
+    public String getSubtype(){
+        return subtype;
+    }
+
+    public float getMinValue(){
+        return minValue;
+    }
+
+    public float getMaxValue(){
+        return maxValue;
+    }
+
+    public String getPrimaryBone(){
+        return primaryBone;
+    }
+
+    public String getMirrorBone(){
+        return mirrorBone;
+    }
+
     public List<AttributeVariant> getVariants(){
         return variants;
     }

src/main/java/electrosphere/menu/MenuGenerators.java

@@ -4,19 +4,25 @@ import electrosphere.controls.ControlHandler.ControlsState;
 import electrosphere.engine.LoadingThread;
 import electrosphere.entity.Entity;
 import electrosphere.entity.EntityDataStrings;
+import electrosphere.entity.EntityUtils;
 import electrosphere.entity.state.equip.EquipState;
 import electrosphere.entity.state.gravity.GravityUtils;
 import electrosphere.entity.state.gravity.GravityTree.GravityTreeState;
 import electrosphere.entity.state.inventory.InventoryUtils;
 import electrosphere.entity.state.inventory.RelationalInventoryState;
 import electrosphere.entity.state.inventory.UnrelationalInventoryState;
+import electrosphere.entity.types.creature.CreatureUtils;
 import electrosphere.entity.types.item.ItemUtils;
+import electrosphere.game.data.creature.type.CreatureType;
+import electrosphere.game.data.creature.type.visualattribute.VisualAttribute;
 import electrosphere.game.server.saves.SaveUtils;
 import electrosphere.main.Globals;
 import electrosphere.main.Main;
 import electrosphere.net.NetUtils;
 import electrosphere.renderer.Model;
 import electrosphere.renderer.RenderingEngine;
+import electrosphere.renderer.actor.Actor;
+import electrosphere.renderer.actor.ActorStaticMorph;
 import electrosphere.renderer.ui.ClickableElement;
 import electrosphere.renderer.ui.DrawableElement;
 import electrosphere.renderer.ui.Element;
@@ -625,9 +631,20 @@ public class MenuGenerators {
             return false;
         }});
 
-        for(int i = 0; i < 6; i++){
+        //pull up character editor
+        Button characterSliderMenuButton = new Button();
+        Label characterSliderMenuLabel = new Label(100,650,fontSize);
+        characterSliderMenuLabel.setText("Character slider menu");
+        characterSliderMenuButton.addChild(characterSliderMenuLabel);
+        scrollable.addChild(characterSliderMenuButton);
+        characterSliderMenuButton.setOnClick(new ClickableElement.ClickEventCallback(){public boolean execute(ClickEvent event){
+            WindowUtils.replaceWindow(WindowStrings.WINDOW_MENU_INGAME_MAIN, createInGameCharacterSliderMenu());
+            return false;
+        }});
+
+        for(int i = 0; i < 5; i++){
             Button someButton = new Button();
-            Label someLabel = new Label(100,650 + i * 100,fontSize);
+            Label someLabel = new Label(100,750 + i * 100,fontSize);
             someLabel.setText("aaaaaa" + i);
             someButton.addChild(someLabel);
             scrollable.addChild(someButton);
@@ -700,6 +717,123 @@ public class MenuGenerators {
         return rVal;
     }
 
+    public static Window createInGameCharacterSliderMenu(){
+        int width = 500;
+        int height = 500;
+        float fontSize = 0.4f;
+        Window rVal = new Window(0,0,width,height);
+        // int screenLeft = (Globals.WINDOW_WIDTH - width)/2;
+        // Div div = new Div();
+        // div.setPositionX(0);
+        // div.setPositionY(0);
+        // div.setWidth(500);
+        // div.setHeight(500);
+        ScrollableContainer scrollable = new ScrollableContainer(0, 0, width, height);
+        rVal.addChild(scrollable);
+        // scrollable.addChild(div);
+        rVal.setOnNavigationCallback(new NavigationEventCallback() {public boolean execute(NavigationEvent event){
+            WindowUtils.replaceWindow(WindowStrings.WINDOW_MENU_INGAME_MAIN, createInGameDebugMainMenu());
+            return false;
+        }});
+        
+        //black texture background
+        ImagePanel imagePanel = new ImagePanel(0,0,width,height + 1000,Globals.blackTexture);
+        // imagePanel.setWidth(width);
+        // imagePanel.setHeight(height);
+        // imagePanel.setTexture(Globals.assetManager.fetchTexture(Globals.blackTexture));
+        scrollable.addChild(imagePanel);
+        
+        //label 1 (back)
+        Button backButton = new Button();
+        Label backLabel = new Label(200,50,fontSize);
+        backLabel.setText("Back");
+        backButton.addChild(backLabel);
+        scrollable.addChild(backButton);
+        backButton.setOnClick(new ClickableElement.ClickEventCallback(){public boolean execute(ClickEvent event){
+            WindowUtils.replaceWindow(WindowStrings.WINDOW_MENU_INGAME_MAIN, createInGameDebugMainMenu());
+            return false;
+        }});
+
+        Entity playerEntity = Globals.playerEntity;
+        Actor playerActor = EntityUtils.getActor(playerEntity);
+        ActorStaticMorph staticMorph = playerActor.getStaticMorph();
+        CreatureType playeCreatureType = Globals.gameConfigCurrent.getCreatureTypeLoader().getCreature(CreatureUtils.getType(playerEntity));
+        int offset = 0;
+        for(VisualAttribute attribute : playeCreatureType.getVisualAttributes()){
+            int posY = offset * 350 + 100;
+            if(attribute.getType().equals("bone")){
+                Slider attributeSlider = new Slider(50,posY,400,100,new Vector3f(0.1f,0.1f,0.1f),new Vector3f(1.0f,0,0));
+                attributeSlider.setOnValueChange(new Slider.OnSliderChangeCallback() {public void onChange(float value) {
+                    float minVal = attribute.getMinValue();
+                    float range = attribute.getMaxValue() - minVal;
+                    float actualValue = minVal + range * value;
+                    switch(attribute.getSubtype()){
+                        case "yaw":
+                        staticMorph.setYaw(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setYaw(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "pitch":
+                        staticMorph.setPitch(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setPitch(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "roll":
+                        staticMorph.setRoll(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setRoll(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "scalex":
+                        staticMorph.setScaleX(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setScaleX(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "scaley":
+                        staticMorph.setScaleY(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setScaleY(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "scalez":
+                        staticMorph.setScaleZ(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setScaleZ(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "offx":
+                        staticMorph.setOffsetX(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setOffsetX(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "offy":
+                        staticMorph.setOffsetY(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setOffsetY(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "offz":
+                        staticMorph.setOffsetZ(attribute.getPrimaryBone(), actualValue);
+                        if(attribute.getMirrorBone() != null){
+                            staticMorph.setOffsetZ(attribute.getMirrorBone(), -actualValue);
+                        }
+                        break;
+                        case "offl":
+                        //TODO
+                        break;
+                    }
+                }});
+                scrollable.addChild(attributeSlider);
+            }
+        }
+
+        return rVal;
+    }
+
     public static Window createNaturalInventoryMenu(UnrelationalInventoryState inventory){
         int width = 500;
         int height = 500;
@@ -856,7 +990,6 @@ public class MenuGenerators {
     }
 
 
-
     public static Window createCharacterMenu(RelationalInventoryState inventory){
         // int screenTop = Globals.WINDOW_HEIGHT - 150;
         int width = 500;

src/main/java/electrosphere/renderer/Model.java

@@ -4,6 +4,7 @@ import electrosphere.renderer.actor.ActorAnimationMask;
 import electrosphere.renderer.actor.ActorBoneRotator;
 import electrosphere.renderer.actor.ActorMeshMask;
 import electrosphere.renderer.actor.ActorShaderMask;
+import electrosphere.renderer.actor.ActorStaticMorph;
 import electrosphere.renderer.actor.ActorTextureMask;
 import electrosphere.renderer.anim.AnimChannel;
 import electrosphere.renderer.anim.Animation;
@@ -371,13 +372,13 @@ public class Model {
         return node_object;
     }
     
-    public void updateNodeTransform(Map<String,ActorBoneRotator> boneRotators){
+    public void updateNodeTransform(Map<String,ActorBoneRotator> boneRotators, ActorStaticMorph staticMorph){
         if(this.root_anim_node != null){
-            update_node_transform(this.root_anim_node,boneRotators);
+            update_node_transform(this.root_anim_node,boneRotators,staticMorph);
         }
     }
 
-    void update_node_transform(AnimNode n, Map<String,ActorBoneRotator> boneRotators){
+    void update_node_transform(AnimNode n, Map<String,ActorBoneRotator> boneRotators, ActorStaticMorph staticMorph){
         if(n.parent != null){
             n.transform = new Matrix4f(n.parent.transform);
         } else {
@@ -397,7 +398,11 @@ public class Model {
             if(boneRotators.containsKey(target_bone.boneID)){
                 n.transform.rotate(boneRotators.get(target_bone.boneID).getRotation());
             }
-            Matrix4f bone_matrix = new Matrix4f(n.transform).mul(target_bone.inverseBindPoseMatrix);
+            Matrix4f bone_matrix = new Matrix4f(n.transform);
+            if(staticMorph != null && staticMorph.getBoneTransforms(n.id) != null){
+                bone_matrix.mul(staticMorph.getBoneTransforms(n.id).getTransform());
+            }
+            bone_matrix.mul(target_bone.inverseBindPoseMatrix);
             bone_matrix = new Matrix4f(globalInverseTransform).mul(bone_matrix);
             target_bone.final_transform = bone_matrix;
 //            if(!toggled){
@@ -419,7 +424,7 @@ public class Model {
         Iterator<AnimNode> node_iterator = n.children.iterator();
         while(node_iterator.hasNext()){
             AnimNode current_node = node_iterator.next();
-            update_node_transform(current_node,boneRotators);
+            update_node_transform(current_node,boneRotators,staticMorph);
         }
     }
     

src/main/java/electrosphere/renderer/actor/Actor.java

@@ -30,6 +30,7 @@ public class Actor {
     List<ActorShaderMask> shaderMasks = new LinkedList<ActorShaderMask>();
     Map<String,ActorTextureMask> textureMap = null;
     Map<String,ActorBoneRotator> boneRotators = new HashMap<String,ActorBoneRotator>();
+    ActorStaticMorph staticMorph;
     
     public Actor(String modelPath){
         this.modelPath = modelPath;
@@ -162,7 +163,7 @@ public class Actor {
     }
 
     void calculateNodeTransforms(Model model){
-        model.updateNodeTransform(boneRotators);
+        model.updateNodeTransform(boneRotators,staticMorph);
     }
     
     // public boolean isPlayingAnimation(){
@@ -356,5 +357,13 @@ public class Actor {
         return boneRotators.get(bone);
     }
 
+    public void setActorStaticMorph(ActorStaticMorph staticMorph){
+        this.staticMorph = staticMorph;
+    }
+
+    public ActorStaticMorph getStaticMorph(){
+        return this.staticMorph;
+    }
+
 
 }

src/main/java/electrosphere/renderer/actor/ActorStaticMorph.java

@@ -0,0 +1,105 @@
+package electrosphere.renderer.actor;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.joml.Matrix4f;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
+
+public class ActorStaticMorph {
+    
+    Map<String,StaticMorphTransforms> boneTransformMap = new HashMap<String,StaticMorphTransforms>();
+
+    public void initBoneTransforms(String boneName){
+        boneTransformMap.put(boneName, new StaticMorphTransforms());
+    }
+
+    public StaticMorphTransforms getBoneTransforms(String boneName){
+        return boneTransformMap.get(boneName);
+    }
+
+    public void setYaw(String boneName, float yaw){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).yaw = yaw;
+        }
+    }
+
+    public void setPitch(String boneName, float pitch){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).pitch = pitch;
+        }
+    }
+
+    public void setRoll(String boneName, float roll){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).roll = roll;
+        }
+    }
+
+    public void setOffsetX(String boneName, float offsetX){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).offset.x = offsetX;
+        }
+    }
+
+    public void setOffsetY(String boneName, float offsetY){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).offset.y = offsetY;
+        }
+    }
+
+    public void setOffsetZ(String boneName, float offsetZ){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).offset.z = offsetZ;
+        }
+    }
+
+    public void setScaleX(String boneName, float scaleX){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).scale.x = scaleX;
+        }
+    }
+
+    public void setScaleY(String boneName, float scaleY){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).scale.y = scaleY;
+        }
+    }
+
+    public void setScaleZ(String boneName, float scaleZ){
+        if(boneTransformMap.containsKey(boneName)){
+            boneTransformMap.get(boneName).scale.z = scaleZ;
+        }
+    }
+
+
+
+    public class StaticMorphTransforms {
+        
+        float yaw = 0.0f;
+        float pitch = 0.0f;
+        float roll = 0.0f;
+        Vector3f offset = new Vector3f(0,0,0);
+        Vector3f scale = new Vector3f(1,1,1);
+
+        public Quaternionf getRotation(){
+            return new Quaternionf().rotateXYZ(yaw, pitch, roll);
+        }
+
+        public Vector3f getOffset(){
+            return offset;
+        }
+
+        public Vector3f getScale(){
+            return scale;
+        }
+
+        public Matrix4f getTransform(){
+            Matrix4f rVal = new Matrix4f();
+            rVal.translationRotateScale(offset, getRotation(), scale);
+            return rVal;
+        }
+    }
+
+}

src/main/java/electrosphere/renderer/actor/ActorUtils.java

@@ -26,6 +26,11 @@ public class ActorUtils {
     public static void applyBlenderRotation(Entity actorEntity){
         EntityUtils.getRotation(actorEntity).rotateLocalX((float)-Math.PI/2);
     }
+
+    public static ActorStaticMorph getStaticMorph(Entity actorEntity){
+        Actor entityActor = EntityUtils.getActor(actorEntity);
+        return entityActor.getStaticMorph();
+    }
     
     
 }

src/main/java/electrosphere/renderer/ui/MenuEventElement.java

@@ -0,0 +1,15 @@
+package electrosphere.renderer.ui;
+
+import electrosphere.renderer.ui.events.MenuEvent;
+
+public interface MenuEventElement extends Element {
+    
+    public void setOnMenuEventCallback(MenuEventCallback callback);
+
+    public abstract interface MenuEventCallback {
+
+        public boolean execute(MenuEvent event);
+
+    }
+
+}

src/main/java/electrosphere/renderer/ui/elements/Slider.java

@@ -10,15 +10,17 @@ import electrosphere.renderer.ui.DraggableElement;
 import electrosphere.renderer.ui.DrawableElement;
 import electrosphere.renderer.ui.FocusableElement;
 import electrosphere.renderer.ui.KeyEventElement;
+import electrosphere.renderer.ui.MenuEventElement;
 import electrosphere.renderer.ui.events.ClickEvent;
 import electrosphere.renderer.ui.events.DragEvent;
 import electrosphere.renderer.ui.events.Event;
 import electrosphere.renderer.ui.events.FocusEvent;
 import electrosphere.renderer.ui.events.KeyboardEvent;
+import electrosphere.renderer.ui.events.MenuEvent;
 import electrosphere.renderer.ui.events.MouseEvent;
 import electrosphere.renderer.ui.events.DragEvent.DragEventType;
 
-public class Slider implements ClickableElement, DraggableElement, FocusableElement, DrawableElement, KeyEventElement {
+public class Slider implements ClickableElement, DraggableElement, FocusableElement, DrawableElement, MenuEventElement {
 
     public int width = 1;
     public int height = 1;
@@ -34,11 +36,12 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
     boolean focused = false;
     FocusEventCallback onFocusCallback;
     FocusEventCallback onLoseFocusCallback;
-    KeyboardEventCallback onKeyPressCallback;
     DragEventCallback onDragStart;
     DragEventCallback onDrag;
     DragEventCallback onDragRelease;
     ClickEventCallback onClick;
+    MenuEventCallback onMenuEvent;
+    OnSliderChangeCallback onChangeValue;
 
     float min = 0.0f;
     float max = 1.0f;
@@ -210,11 +213,6 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
         onLoseFocusCallback = callback;
     }
 
-    @Override
-    public void setOnPress(KeyboardEventCallback callback) {
-        onKeyPressCallback = callback;
-    }
-
     @Override
     public void setOnDragStart(DragEventCallback callback) {
         this.onDragStart = callback;
@@ -234,6 +232,15 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
     public void setOnClick(ClickEventCallback callback) {
         this.onClick = callback;
     }
+    
+    @Override
+    public void setOnMenuEventCallback(MenuEventCallback callback) {
+        onMenuEvent = callback;
+    }
+
+    public void setOnValueChange(OnSliderChangeCallback callback){
+        this.onChangeValue = callback;
+    }
 
 
     @Override
@@ -256,13 +263,28 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
                     propagate = true;
                 }
             }
-        } else if(event instanceof KeyboardEvent){
+        } else if(event instanceof MenuEvent){
-            KeyboardEvent keyEvent = (KeyboardEvent)event;
+            MenuEvent menuEvent = (MenuEvent) event;
-            if(onKeyPressCallback != null){
+            if(onMenuEvent != null){
-                propagate = onKeyPressCallback.execute(keyEvent);
+                onMenuEvent.execute(menuEvent);
             } else {
                 //default behavior
-                propagate = true;
+                switch(menuEvent.getType()){
+                    case INCREMENT:
+                    value = Math.min(value + ((max - min) * 0.01f),max);
+                    if(onChangeValue != null){
+                        onChangeValue.onChange(value);
+                    }
+                    propagate = false;
+                    break;
+                    case DECREMENT:
+                    value = Math.max(value - ((max - min) * 0.01f),min);
+                    if(onChangeValue != null){
+                        onChangeValue.onChange(value);
+                    }
+                    propagate = false;
+                    break;
+                }
             }
         } else if(event instanceof DragEvent){
             DragEvent dragEvent = (DragEvent) event;
@@ -298,11 +320,21 @@ public class Slider implements ClickableElement, DraggableElement, FocusableElem
                     int percentage = clickEvent.getCurrentX() - positionX;
                     int max = width;
                     value = Math.max(Math.min((float)percentage/max,1.0f),0.0f);
+                    if(onChangeValue != null){
+                        onChangeValue.onChange(value);
+                    }
                     propagate = false;
                 }
             }
         }
         return propagate;
     }
+
+
+    public interface OnSliderChangeCallback {
+
+        public void onChange(float value);
+
+    }
     
 }

src/main/java/electrosphere/renderer/ui/events/MenuEvent.java

@@ -0,0 +1,20 @@
+package electrosphere.renderer.ui.events;
+
+public class MenuEvent implements Event {
+    
+    public static enum MenuEventType {
+        INCREMENT,
+        DECREMENT,
+    }
+
+    MenuEventType type;
+
+    public MenuEvent(MenuEventType type){
+        this.type = type;
+    }
+
+    public MenuEventType getType(){
+        return type;
+    }
+
+}