omni::input::Controller Class Reference

Input controller controls which inputs are currently active Implemented as a singleton. More...

#include <Controller.h>

Collaboration diagram for omni::input::Controller:

Public Member Functions
bool	isActive (input::Interface *) const
int	activeCount (input::Interface *) const
void	add (input::Interface *)
void	remove (input::Interface *)
void	activate (input::Interface *)
	Activate input. More...
void	deactivate (input::Interface *)
	Deactivate input. More...

Static Public Member Functions
static Controller *	instance ()

Private Member Functions
	Controller ()
	~Controller ()

Private Attributes
std::unordered_map < input::Interface *, int >	usage_

Static Private Attributes
static Controller *	instance_ = nullptr

Detailed Description

Input controller controls which inputs are currently active Implemented as a singleton.

Constructor & Destructor Documentation

omni::input::Controller::Controller ( )

private

                           {

    }

omni::input::Controller::~Controller ( )

private

                            {
    }

Member Function Documentation

void omni::input::Controller::activate

(

input::Interface *

_input

)

Activate input.

Increment usage count

                                                    {
      if (!_input) return;

      if (!isActive(_input)) {
        // Activate input if it not in usage list
        _input->activate();

        // Set usage count to 1 initially
        usage_[_input] = 1;
      } else {
        /// Increment usage count
        ++usage_[_input];
      }
    }

int omni::input::Controller::activeCount

(

input::Interface *

_input

)

const

                                                            {
      if (usage_.count(_input) == 0) return 0;

      return usage_.at(_input);
    }

void omni::input::Controller::add

(

input::Interface *

_input

)

                                               {
      if (usage_.count(_input) > 0) return;

      usage_[_input] = 0; // Do not activate the input
    }

void omni::input::Controller::deactivate

(

input::Interface *

_input

)

Deactivate input.

                                                      {
      if (usage_.count(_input) == 0) return;
      if (usage_[_input] == 0) return;

      --usage_[_input];

      if (!isActive(_input)) {
        _input->deactivate();
      }
    }

Controller * omni::input::Controller::instance ( )

static

                                     {
      if (!instance_) {
        instance_ = new Controller;
      }
      return instance_;
    }

bool omni::input::Controller::isActive

(

input::Interface *

_input

)

const

                                                          {
      return activeCount(_input) > 0;
    }

void omni::input::Controller::remove

(

input::Interface *

_input

)

                                                  {
      if (usage_.count(_input) == 0) return;
      deactivate(_input);
      usage_.erase(_input);
    }

Field Documentation

Controller * omni::input::Controller::instance_ = nullptr

staticprivate

std::unordered_map<input::Interface *, int> omni::input::Controller::usage_

private

---

The documentation for this class was generated from the following files:

• include/omni/input/Controller.h
• src/lib/input/Controller.cpp