todo: find positioning bug

src/scene/graphicalnode.cpp

@@ -14,6 +14,10 @@ void GraphicalNode::setSceneTree(SceneTree *tree){
     m_scene = tree;
 }
 
+void GraphicalNode::resetTransform(){
+    setTransform(glm::mat4());
+}
+
 // tools
 void GraphicalNode::moveTo(const glm::vec3 &position)
 {
@@ -111,6 +115,8 @@ void GraphicalNode::setParentVisible(bool visible)
 
 void GraphicalNode::updateVisibility(bool visible)
 {
+    if(!m_scene)
+        return;
     if(visible)
         m_scene->addToIndex(this);
     else

src/scene/graphicalnode.h

@@ -50,6 +50,7 @@ public:
     const glm::mat4& getTransform() { return m_transform; }
     void setParentTransform(const glm::mat4 &transform);
     const glm::mat4& getParentTransform() { return m_parentTransform; }
+    void resetTransform();
 
     // visibility methods
     bool isVisible(){return m_parentVisible && m_visible;}

src/scene/gui/backgroundnode.cpp

@@ -1,5 +1,8 @@
 #include "backgroundnode.h"
 
+#include "engine.h"
+#include "scene/scenetree.h"
+
 #include "glm/vec2.hpp"
 #include "glm/vec3.hpp"
 
@@ -9,7 +12,9 @@
 BackGroundNode::BackGroundNode(glm::vec2 dimension, glm::vec3 color, float opacity,float depth):
     m_dimension(dimension),
     m_color(color),
-    m_opacity(opacity)
+    m_color_updated(false),
+    m_opacity(opacity),
+    m_opacity_updated(false)
 {
     Mesh* mesh = new Mesh();
     mesh->addRectangle2D(glm::vec2(0),dimension);
@@ -19,7 +24,8 @@ BackGroundNode::BackGroundNode(glm::vec2 dimension, glm::vec3 color, float opaci
     mesh->setMaterial(mat);
     mesh->setDepth(depth);
     mesh->initGL();
-    m_mesh = new MeshNode(mesh,false);
+    m_mesh = new MeshNode(mesh);
+    addChild(m_mesh);
 }
 
 void BackGroundNode::update(){

src/scene/gui/labelnode.cpp

@@ -5,7 +5,10 @@
 #include "SparrowRenderer/mesh.h"
 #include "SparrowRenderer/phongmaterial.h"
 
-LabelNode::LabelNode(){
+LabelNode::LabelNode():
+    m_string(""),
+    m_color(glm::vec3(1,1,1))
+{
     Font* font = RESOURCE_GET(Font,"shellfont");
     m_text = font->getTextNode(m_string,m_color,32);
     addChild(m_text);
@@ -23,7 +26,10 @@ void LabelNode::setColor(glm::vec3 color){
 }
 
 glm::vec2 LabelNode::getDimension(){
-    return m_text->getDimension();
+    if(m_text)
+        return m_text->getDimension();
+    else
+        return glm::vec2(0,0);
 }
 
 bool LabelNode::wasUpdated(){

src/scene/gui/labelnode.h

@@ -7,9 +7,9 @@
 class LabelNode : public GUINode
 {
     TextNode* m_text;
-    glm::vec3 m_color;
     std::string m_string;
     bool m_string_updated;
+    glm::vec3 m_color;
     bool m_color_updated;
     bool m_was_updated;
 

src/scene/gui/scrollbarnode.cpp

@@ -1,57 +1,86 @@
 #include "scrollbarnode.h"
 
+#include <iostream>
+
 #include "scene/meshnode.h"
 
 #include "SparrowRenderer/mesh.h"
 #include "SparrowRenderer/phongmaterial.h"
 #include "sparrowshell/sparrowshell.h"
 
-ScrollBarNode::ScrollBarNode(glm::vec2 dimension):
+ScrollBarNode::ScrollBarNode(glm::vec2 dimension, glm::vec3 bar_color):
     m_dimension(dimension),
     m_bar_position(glm::vec2(0)),
-    m_bar_dimension(glm::vec2(0))
+    m_bar_dimension(m_dimension),
+    m_bar_color(bar_color),
+    m_bar_color_updated(false),
+    m_bar_resized(false),
+    m_bar_moved(false)
 {
     Mesh* mesh = new Mesh();
     mesh->addRectangle2D(glm::vec2(0),m_dimension);
     PhongMaterial* mat = new PhongMaterial();
-    mat->diffuse = glm::vec3(0,0,0.5);
+    mat->diffuse = m_bar_color;
     mat->m_opacity = 0.8;
     mesh->setMaterial(mat);
     mesh->setDepth(SparrowShell::SHELL_DEPTH+1);
     mesh->initGL();
-    m_bar = new MeshNode(mesh,false);
+    m_bar = new MeshNode(mesh);
     addChild(m_bar);
 }
 
 void ScrollBarNode::update()
 {
     GUINode::update();
-    if(m_barResized)
+    if(m_bar_resized)
     {
-        m_bar->resize2D(m_bar_dimension,m_last_bar_dimension);
-        m_barResized = false;
+        if(m_total_size > m_bar_size){
+            m_bar->resetTransform();
+            m_bar_dimension.y = m_dimension.y * ((float)m_bar_size / (float)m_total_size);
+            m_bar->resize2D(m_dimension,m_bar_dimension);
+            m_bar_resized = false;
+        }
     }
-    if(m_barMoved)
+    if(m_bar_moved)
     {
+        m_bar_position = glm::vec2(0,(m_dimension.y /m_total_size) * m_index_position);
+        std::cout<< "Pos vec: " << m_bar_position.x << " " << m_bar_position.y << std::endl;
         m_bar->moveTo2D(m_bar_position);
-        m_barMoved = false;
+        glm::mat4 m = m_bar->getTransform();
+        glm::vec2 v = glm::vec2(m[3].x,m[3].y);
+        std::cout << "Pos tr : " << v.x << " " << v.y << std::endl;
+        m_bar_moved = false;
+    }
+    if(m_bar_color_updated)
+    {
+        PhongMaterial* mat = (PhongMaterial*) m_bar->getGeometryNode()->mesh->getMaterial();
+        mat->diffuse = m_bar_color;
+        m_bar_color_updated = false;
     }
-}
-
-void ScrollBarNode::moveBar(glm::vec2 position)
-{
-    m_bar_position = position;
-    m_barMoved = true;
-}
-
-void ScrollBarNode::resizeBar(glm::vec2 dimension)
-{
-    m_last_bar_dimension = m_bar_dimension;
-    m_bar_dimension = dimension;
-    m_barResized = true;
 }
 
 glm::vec2 ScrollBarNode::getDimension()
 {
     return m_dimension;
 }
+
+void ScrollBarNode::setBarColor(glm::vec3 color)
+{
+    m_bar_color = color;
+    m_bar_color_updated = true;
+}
+
+void ScrollBarNode::setIndex(int index){
+    m_index_position = index;
+    m_bar_moved = true;
+}
+
+void ScrollBarNode::setBarSize(int size){
+    m_bar_size = size;
+    m_bar_resized = true;
+}
+
+void ScrollBarNode::setSize(int total){
+    m_total_size = total;
+    m_bar_resized = true;
+}

src/scene/gui/scrollbarnode.h

@@ -10,17 +10,27 @@ class ScrollBarNode : public GUINode
 protected:
     glm::vec2 m_dimension;
     glm::vec2 m_bar_position;
+    int m_index_position;
+    int m_bar_size;
+    int m_total_size;
     glm::vec2 m_bar_dimension;
     glm::vec2 m_last_bar_dimension;
+    glm::vec3 m_bar_color;
+    bool m_bar_color_updated;
     MeshNode* m_bar;
-    bool m_barResized;
-    bool m_barMoved;
+    bool m_bar_resized;
+    bool m_bar_moved;
 public:
-    ScrollBarNode(glm::vec2 dimension);
+    ScrollBarNode(glm::vec2 dimension,glm::vec3 bar_color);
     void update();
     glm::vec2 getDimension();
-    void moveBar(glm::vec2 position);
+    void moveBar(float position);
     void resizeBar(glm::vec2 dimension);
+    void setBarColor(glm::vec3 color);
+    void setPercent(float percent);
+    void setIndex(int index);
+    void setBarSize(int size);
+    void setSize(int total);
 };
 
 #endif // SCROLLBARNODE_H

src/sparrowshell/shellscrollbar.cpp

@@ -12,10 +12,12 @@ ShellScrollBar::ShellScrollBar(SparrowShell *shell):
         glm::vec2(
             SparrowShell::SCROLLBAR_PIXEL_WIDTH,
             SparrowShell::DEFAULT_FONT_SIZE*SparrowShell::BUFFER_DISPLAYED_LINES
-            )
+            ),
+        glm::vec3(0,0,0.5)
         ),
     m_shell(shell)
 {
+    setBarSize(SparrowShell::BUFFER_DISPLAYED_LINES);
 //    MeshNode(nullptr,false);
 //    m_position = glm::vec2(m_shell->getDimension().x-SparrowShell::SCROLLBAR_PIXEL_WIDTH,0);
 //    m_max_height = ;
@@ -34,19 +36,15 @@ ShellScrollBar::ShellScrollBar(SparrowShell *shell):
 //    m_geometry.mesh = mesh;
 }
 
-void ShellScrollBar::update(){
-    ScrollBarNode::update();
-    int size = m_shell->getBuffer()->size();
-    float cran = (m_dimension.y/(float)size);
-    int indexCursor = m_shell->getIndex();
-
+void ShellScrollBar::update()
+{
     if (m_shell->isBufferResized()){
-        resizeBar(glm::vec2(m_dimension.x,(int)(cran * SparrowShell::BUFFER_DISPLAYED_LINES)));
-//        resize2D(m_dimension,new_dim);
+        setSize(m_shell->getBuffer()->size());
     }
     if (m_shell->indexMoved())
     {
-        m_bar_position.y = cran * indexCursor;
-        moveBar(m_bar_position);
+        setIndex(m_shell->getIndex());
     }
+    ScrollBarNode::update();
 }
+

src/sparrowshell/sparrowshell.cpp

@@ -37,8 +37,11 @@ SparrowShell::SparrowShell(sf::Window* window):
 
     //Create mesh for background
     m_background = new BackGroundNode(m_dimension,glm::vec3(0.1,0.1,0.1),0.75,SHELL_DEPTH);
+    m_background->setVisible(false);
     //Create mesh for scrollbar
     m_scrollbar = new ShellScrollBar(this);
+    m_scrollbar->setVisible(false);
+    m_scrollbar->moveTo2D(glm::vec2(m_dimension.x-SCROLLBAR_PIXEL_WIDTH,0));
 
     m_script = new ScriptNode();
 
@@ -49,9 +52,9 @@ SparrowShell::SparrowShell(sf::Window* window):
 
     this->addChild(m_background);
     this->addChild(m_buffer);
+    this->addChild(m_input_node);
     this->addChild(m_scrollbar);
     this->addChild(m_script);
-    this->addChild(m_input_node);
 }
 
 SparrowShell::InputCallBack::InputCallBack(SparrowShell* shell,TextInputNode* textinput):
@@ -80,9 +83,9 @@ void SparrowShell::out(std::string str,glm::vec3 color)
     tnode->setDepth(SHELL_DEPTH+1);
     m_buffer->push(tnode);
     scrollDown();
+    std::cout << "size: " << m_buffer->size() << std::endl;
     if (m_buffer->size() > SparrowShell::BUFFER_DISPLAYED_LINES)
         m_resizeBuffer = true;
-//    getEngine().getScene()->updateShaders();
 }
 
 void SparrowShell::scrollUp()
@@ -131,20 +134,8 @@ void SparrowShell::toggleShell()
 
 void SparrowShell::update()
 {
-    m_resizeBuffer = false;
-    m_indexMoved = false;
     if(m_shellEnabled){
         auto input = getEngine().getInput();
-//        for(auto action : input->getActions()){
-          /*  if (action == m_move_cursor_left){
-                if (m_input_cursor_pos > 0)
-                    moveCursorLeft();
-            }
-            else if(action == m_move_cursor_right){
-                if(m_input_cursor_pos < m_input_string.length())
-                    moveCursorRight();
-            }*/
-//        }
         int scroll = input->getDeltaVerticalScroll();
         if(scroll < 0)
             scrollDown();
@@ -152,4 +143,7 @@ void SparrowShell::update()
             scrollUp();
     }
     GUINode::update();
+    m_resizeBuffer = false;
+    m_indexMoved = false;
+
 }

src/test/main.cpp

@@ -388,6 +388,11 @@ int main(){
     engine.getShell()->out("Hello World!");
     engine.getShell()->out("Starting test :");
 
+
+//    engine.getScene()->updateShaders();
+//    BackGroundNode* bgrn = new BackGroundNode(glm::vec2(10),glm::vec3(1.,1.,1.),1,1);
+//    engine.getScene()->getRootObject()->addChild(bgrn);
+
     // preparing shaders and launching the engine
     engine.getScene()->updateShaders();
     engine.start();