MatrixStack.hpp

#pragma once
#ifndef __H__OCULAR_MATH_MATRIX_STACK__H__
#define __H__OCULAR_MATH_MATRIX_STACK__H__

#include "Matrix4x4.hpp"
#include "Exceptions/Exception.hpp"
#include <stack>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Math
    {
        class MatrixStack
        {
        public:

            MatrixStack()
            {
            
            }

            ~MatrixStack()
            {
            
            }

            //------------------------------------------------------------------------------

            void loadIdentity()
            {
                m_Stack.push(Matrix4x4());
            }

            void combine(Matrix4x4 const matrix)
            {
                if(empty())
                {
                    m_Stack.push(matrix);
                }
                else 
                {
                    Matrix4x4 top;
                    pop(&top);

                    top *= matrix;

                    m_Stack.push(top);
                }
            }

            void push(Matrix4x4 const matrix)
            {
                m_Stack.push(matrix);
            }

            bool pop(Matrix4x4* matrix)
            {
                bool result = false;

                if(!empty())
                {
                    if(matrix != nullptr)
                    {
                        *matrix = m_Stack.top();
                    }

                    m_Stack.pop();
                    result = true;
                }

                return result;
            }

            bool peek(Matrix4x4* matrix)
            {
                bool result = false;

                if(!empty())
                {
                    if(matrix != nullptr)
                    {
                        *matrix = m_Stack.top();
                    }

                    result = true;
                }

                return result;
            }

            bool empty()
            {
                return m_Stack.empty();
            }

            unsigned size()
            {
                return static_cast<unsigned>(m_Stack.size());
            }

            void clear()
            {
                while(!m_Stack.empty())
                {
                    m_Stack.pop();
                }
            }

        protected:

        private:

            std::stack<Matrix4x4> m_Stack;
        };
    }
}
//------------------------------------------------------------------------------------------

#endif