Ejemplo n.º 1
0
static void handle_tick(game_context_s *context, void *data, const nothing_s *n)
{
    input_handler_s *input_handler = data;

    // process the callback-based events
    target_context = context;
    glfwPollEvents();
    target_context = NULL;

    // process joysticks
    for(int i = 0; i < MAX_JOYSTICKS; i++)
    {
        if(glfwGetJoystickParam(i, GLFW_PRESENT) == GL_TRUE)
        {
            joystick_event_s *joystick = &input_handler->joysticks[i];

            int axis_count = glfwGetJoystickParam(i, GLFW_AXES);
            array_set_length(joystick->axes, axis_count);
            glfwGetJoystickPos(i, array_get_ptr(joystick->axes), axis_count);

            int button_count = glfwGetJoystickParam(i, GLFW_BUTTONS);
            array_set_length(joystick->buttons, button_count);
            glfwGetJoystickButtons(i, array_get_ptr(joystick->buttons),
                button_count);

            broadcast_input_handler_joystick_event(context, *joystick);
        }
    }
}
Ejemplo n.º 2
0
void RawController::update(){
	// Update buttons flags.
	const float * rawAxes = glfwGetJoystickAxes(_id, &_rawAxesCount);
	const unsigned char * rawButtons = glfwGetJoystickButtons(_id, &_rawButtonsCount);
	
	if(_rawAxesCount != int(allAxes.size())){
		allAxes.resize(_rawAxesCount);
	}
	if(_rawButtonsCount != int(allButtons.size())){
		allButtons.resize(_rawButtonsCount);
	}
	
	for(int aid = 0; aid < _rawAxesCount; ++aid){
		allAxes[aid] = rawAxes[aid];
	}
	
	for(int bid = 0; bid < _rawButtonsCount; ++bid){
		const bool pressed = (rawButtons[bid] == GLFW_PRESS);
		if(pressed){
			if(allButtons[bid].pressed){
				// Already pressed.
				allButtons[bid].first = false;
			} else {
				allButtons[bid].pressed = true;
				allButtons[bid].first = true;
			}
		} else {
			allButtons[bid].pressed = false;
			allButtons[bid].first = false;
		}
	}
	
}
Ejemplo n.º 3
0
void Window::
pollGamepads()
{
    // NB: GLFW limitation limits operation to a single window
    Window* window = main_window_.get();
    if (window != nullptr && window->controller_ != nullptr) {
        for (int i=0; i<MAX_GAMEPADS; ++i) {
            // NB: data is copied into newState object to minimize changes when
            // porting from GLFW2 to GLFW3
            int num_glfw_axes = 0;
            const float* axes = glfwGetJoystickAxes(i, &num_glfw_axes);
            int num_axes = num_glfw_axes < MAX_GAMEPAD_AXES
                               ? num_glfw_axes : MAX_GAMEPAD_AXES;
            int num_glfw_buttons = 0;
            const unsigned char*
                buttons = glfwGetJoystickButtons(i, &num_glfw_buttons);
            int num_buttons = num_glfw_buttons < MAX_GAMEPAD_BUTTONS
                ? num_glfw_buttons : MAX_GAMEPAD_BUTTONS;
            GamepadState newState;
            newState.present = glfwJoystickPresent(i) == GL_TRUE;
            for (int j=0; j<num_axes; ++j) {
                newState.axis[j] = axes[j];
            }
            for (int j=0; j<num_buttons; ++j) {
                newState.button[j] = buttons[j];
            }
            if (newState.present != gamepad_state_[i].present) {
                window->controller_->
                    windowControlGamepadPresenceChanged(window->shared_from_this(),
                    i,
                    newState.present);
            }
            // a few hacks to standardize results from a Microsoft Gamepad
            newState.axis[1] = -newState.axis[1];
            newState.axis[3] = -newState.axis[3];
            newState.axis[7] = newState.axis[2] < 0.f ? -newState.axis[2] : 0.f;
            newState.axis[2] = newState.axis[2] > 0.f ? newState.axis[2] : 0.f;
            // TODO: dpad seems to be missing
            for (int j=0; j<num_axes; ++j) {
                if (newState.axis[j] != gamepad_state_[i].axis[j]) {
                    window->controller_->
                      windowControlGamepadAxisMoved(window->shared_from_this(),
                                                    i,
                                                    j,
                                                    newState.axis[j]);
                }
            }
            for (int j=0; j<num_buttons; ++j) {
                if (newState.button[j] != gamepad_state_[i].button[j]) {
                    window->controller_->windowControlGamepadButtonChanged(
                                            window->shared_from_this(),
                                            i,
                                            j,
                                            newState.button[j] == GLFW_PRESS);
                }
            }
            gamepad_state_[i] = newState;
        }
    }
}
Ejemplo n.º 4
0
///@brief Check all available joysticks for an Xbox Controller
/// and store its idx in g_joystickIdx.
/// Unfortunately, this operation is too time-consuming to call every frame
/// in a VR app. The workaround is to call it on key press, space or 'G'.
void FindPreferredJoystick()
{
    g_joystickIdx = -1;
    for (int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; ++i)
    {
        if (GL_FALSE == glfwJoystickPresent(i))
            continue;

        const char* pJoyName = glfwGetJoystickName(i);
        if (pJoyName == NULL)
            continue;

        int numAxes = 0;
        int numButtons = 0;
        glfwGetJoystickAxes(i, &numAxes);
        glfwGetJoystickButtons(i, &numButtons);
        LOG_INFO("Glfw found Joystick #%d: %s w/ %d axes, %d buttons", i, pJoyName, numAxes, numButtons);

        // Take an educated guess that this is an Xbox controller - glfw's
        // id string says "Microsoft PC Joystick" for most gamepad types.
        ///@todo Why does GLFW on Linux return a different, more descriptive string?
        if (numAxes == 5 && numButtons == 14)
        {
            g_joystickIdx = i;
            return;
        }
    }
}
Ejemplo n.º 5
0
void joystick()
{
    static char s_lastButtons[256] = { 0 };

    ///@todo Handle multiple joysticks

    ///@todo Do these calls take time? We can move them out if so
    int joyStick1Present = GL_FALSE;
    joyStick1Present = glfwJoystickPresent(g_joystickIdx);
    if (joyStick1Present != GL_TRUE)
    {
        if (g_joystickIdx == -1)
            return;
    }

    // Poll joystick
    int numAxes = 0;
    const float* pAxisStates = glfwGetJoystickAxes(g_joystickIdx, &numAxes);
    int numButtons = 0;
    const unsigned char* pButtonStates = glfwGetJoystickButtons(g_joystickIdx, &numButtons);

    // Take an educated guess that this is an Xbox controller - glfw's
    // id string says "Microsoft PC Joystick" for most gamepad types.
    ///@todo Why does GLFW on Linux return a different, more descriptive string?
    if (numAxes == 5 && numButtons == 14)
    {
        joystick_XboxController(g_joystickIdx, pAxisStates, numAxes, pButtonStates, numButtons, s_lastButtons);
    }
    memcpy(s_lastButtons, pButtonStates, numButtons);
}
Ejemplo n.º 6
0
void
plUpdatePad(CControllerState *state)
{
	if(currentPad >= numPads)
		return;

	int n = currentPad;
//	printf("joy: %s\n", glfwGetJoystickName(GLFW_JOYSTICK_1+n));
	int count;
	const float *axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1+n, &count);
	state->leftX = axes[0] * 32767;
	state->leftY = axes[1] * 32767;
	state->rightX = axes[2] * 32767;
	state->rightY = axes[3] * 32767;
	const unsigned char *buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1+n, &count);
	state->triangle   = buttons[12];
	state->circle     = buttons[13];
	state->cross      = buttons[14];
	state->square     = buttons[15];
	state->l1         = buttons[10];
	state->l2         = buttons[8];
	state->leftshock  = buttons[1];
	state->r1         = buttons[11];
	state->r2         = buttons[9];
	state->rightshock = buttons[2];
	state->select     = buttons[0];
	state->start      = buttons[3];
	state->up         = buttons[4];
	state->right      = buttons[5];
	state->down       = buttons[6];
	state->left       = buttons[7];
}
Ejemplo n.º 7
0
/** Updated joystick info
 */
static void orxFASTCALL orxJoystick_GLFW_UpdateInfo(orxU32 _u32ID)
{
  /* Checks */
  orxASSERT(_u32ID <= GLFW_JOYSTICK_LAST);

  /* Needs update? */
  if(sstJoystick.astJoyInfoList[_u32ID].fTimeStamp != sstJoystick.pstClockInfo->fTime)
  {
    /* Is connected? */
    if(glfwGetJoystickParam((int)_u32ID, GLFW_PRESENT) != GL_FALSE)
    {
      /* Gets axes values */
      glfwGetJoystickPos((int)_u32ID, sstJoystick.astJoyInfoList[_u32ID].afAxisInfoList, orxJOYSTICK_AXIS_SINGLE_NUMBER);

      /* Updates connection status */
      sstJoystick.astJoyInfoList[_u32ID].bIsConnected = orxTRUE;

      /* Gets button values */
      glfwGetJoystickButtons((int)_u32ID, sstJoystick.astJoyInfoList[_u32ID].au8ButtonInfoList, orxJOYSTICK_BUTTON_SINGLE_NUMBER);
    }
    else
    {
      /* Clears info */
      orxMemory_Zero(&sstJoystick.astJoyInfoList[_u32ID], sizeof(orxJOYSTICK_INFO));
    }

    /* Updates time stamp */
    sstJoystick.astJoyInfoList[_u32ID].fTimeStamp = sstJoystick.pstClockInfo->fTime;
  }

  /* Done! */
  return;
}
Ejemplo n.º 8
0
static void refresh_joysticks(void)
{
    int i;

    for (i = 0;  i < sizeof(joysticks) / sizeof(Joystick);  i++)
    {
        Joystick* j = joysticks + i;

        if (glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_PRESENT))
        {
            int axis_count, button_count;

            free(j->name);
            j->name = strdup(glfwGetJoystickName(GLFW_JOYSTICK_1 + i));

            axis_count = glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_AXES);
            if (axis_count != j->axis_count)
            {
                j->axis_count = axis_count;
                j->axes = realloc(j->axes, j->axis_count * sizeof(float));
            }

            glfwGetJoystickAxes(GLFW_JOYSTICK_1 + i, j->axes, j->axis_count);

            button_count = glfwGetJoystickParam(GLFW_JOYSTICK_1 + i, GLFW_BUTTONS);
            if (button_count != j->button_count)
            {
                j->button_count = button_count;
                j->buttons = realloc(j->buttons, j->button_count);
            }

            glfwGetJoystickButtons(GLFW_JOYSTICK_1 + i, j->buttons, j->button_count);

            if (!j->present)
            {
                printf("Found joystick %i named \'%s\' with %i axes, %i buttons\n",
                       i + 1, j->name, j->axis_count, j->button_count);

                joystick_count++;
            }

            j->present = GL_TRUE;
        }
        else
        {
            if (j->present)
            {
                printf("Lost joystick %i named \'%s\'\n", i + 1, j->name);

                free(j->name);
                free(j->axes);
                free(j->buttons);
                memset(j, 0, sizeof(Joystick));

                joystick_count--;
            }
        }
    }
}
Ejemplo n.º 9
0
// Joysticks
void VogueWindow::UpdateJoySticks()
{
	for (int i = 0; i < sizeof(m_joysticks) / sizeof(Joystick); i++)
	{
		Joystick* j = m_joysticks + i;

		if (glfwJoystickPresent(GLFW_JOYSTICK_1 + i))
		{
			const float* axes;
			const unsigned char* buttons;
			int axis_count, button_count;

			free(j->m_name);
			j->m_name = strdup(glfwGetJoystickName(GLFW_JOYSTICK_1 + i));

			axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1 + i, &axis_count);
			if (axis_count != j->m_axisCount)
			{
				j->m_axisCount = axis_count;
				j->m_axes = (float*)realloc(j->m_axes, j->m_axisCount * sizeof(float));
			}

			memcpy(j->m_axes, axes, axis_count * sizeof(float));

			buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1 + i, &button_count);
			if (button_count != j->m_buttonCount)
			{
				j->m_buttonCount = button_count;
				j->m_buttons = (unsigned char*)realloc(j->m_buttons, j->m_buttonCount);
			}

			memcpy(j->m_buttons, buttons, button_count * sizeof(unsigned char));

			if (!j->m_present)
			{
				printf("\nFound joystick %i named \'%s\' with %i axes, %i buttons\n",
					i + 1, j->m_name, j->m_axisCount, j->m_buttonCount);

				m_joystickCount++;
			}

			j->m_present = GL_TRUE;
		}
		else
		{
			if (j->m_present)
			{
				printf("\nLost joystick %i named \'%s\'\n", i + 1, j->m_name);

				free(j->m_name);
				free(j->m_axes);
				free(j->m_buttons);
				memset(j, 0, sizeof(Joystick));

				m_joystickCount--;
			}
		}
	}
}
Ejemplo n.º 10
0
bool Controller::getDRight()
{
	if (!controllerPresent())
		return false;
	int count = 0;
	const unsigned char* buttons = glfwGetJoystickButtons(0, &count);
	return buttons[11];
}
Ejemplo n.º 11
0
bool Controller::getLeftJoyStickPressed()
{
	if (!controllerPresent())
		return false;
	int count = 0;
	const unsigned char* buttons = glfwGetJoystickButtons(0, &count);
	return buttons[8];
}
Ejemplo n.º 12
0
void ImGui_ImplGlfw_NewFrame()
{
    ImGuiIO& io = ImGui::GetIO();
    IM_ASSERT(io.Fonts->IsBuilt());     // Font atlas needs to be built, call renderer _NewFrame() function e.g. ImGui_ImplOpenGL3_NewFrame() 

    // Setup display size
    int w, h;
    int display_w, display_h;
    w = Global.iWindowWidth;
    h = Global.iWindowHeight;
    display_w = w;
    display_h = h;
    io.DisplaySize = ImVec2((float)w, (float)h);
    io.DisplayFramebufferScale = ImVec2(w > 0 ? ((float)display_w / w) : 0, h > 0 ? ((float)display_h / h) : 0);

    // Setup time step
    double current_time = glfwGetTime();
    io.DeltaTime = g_Time > 0.0 ? (float)(current_time - g_Time) : (float)(1.0f/60.0f);
    g_Time = current_time;

    ImGui_ImplGlfw_UpdateMousePosAndButtons();
    ImGui_ImplGlfw_UpdateMouseCursor();

    // Gamepad navigation mapping [BETA]
    memset(io.NavInputs, 0, sizeof(io.NavInputs));
    if (io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad)
    {
        // Update gamepad inputs
        #define MAP_BUTTON(NAV_NO, BUTTON_NO)       { if (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS) io.NavInputs[NAV_NO] = 1.0f; }
        #define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); if (v > 1.0f) v = 1.0f; if (io.NavInputs[NAV_NO] < v) io.NavInputs[NAV_NO] = v; }
        int axes_count = 0, buttons_count = 0;
        const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
        const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
        MAP_BUTTON(ImGuiNavInput_Activate,   0);     // Cross / A
        MAP_BUTTON(ImGuiNavInput_Cancel,     1);     // Circle / B
        MAP_BUTTON(ImGuiNavInput_Menu,       2);     // Square / X
        MAP_BUTTON(ImGuiNavInput_Input,      3);     // Triangle / Y
        MAP_BUTTON(ImGuiNavInput_DpadLeft,   13);    // D-Pad Left
        MAP_BUTTON(ImGuiNavInput_DpadRight,  11);    // D-Pad Right
        MAP_BUTTON(ImGuiNavInput_DpadUp,     10);    // D-Pad Up
        MAP_BUTTON(ImGuiNavInput_DpadDown,   12);    // D-Pad Down
        MAP_BUTTON(ImGuiNavInput_FocusPrev,  4);     // L1 / LB
        MAP_BUTTON(ImGuiNavInput_FocusNext,  5);     // R1 / RB
        MAP_BUTTON(ImGuiNavInput_TweakSlow,  4);     // L1 / LB
        MAP_BUTTON(ImGuiNavInput_TweakFast,  5);     // R1 / RB
        MAP_ANALOG(ImGuiNavInput_LStickLeft, 0,  -0.3f,  -0.9f);
        MAP_ANALOG(ImGuiNavInput_LStickRight,0,  +0.3f,  +0.9f);
        MAP_ANALOG(ImGuiNavInput_LStickUp,   1,  +0.3f,  +0.9f);
        MAP_ANALOG(ImGuiNavInput_LStickDown, 1,  -0.3f,  -0.9f);
        #undef MAP_BUTTON
        #undef MAP_ANALOG
        if (axes_count > 0 && buttons_count > 0)
            io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
        else
            io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
    }
}
Ejemplo n.º 13
0
				void update() {
					_prev_buttons.resize(_buttons_count, 0);
					for (int i = 0; i < _buttons_count; i++) {
						_prev_buttons[i] = _buttons[i];
					}
					
					_buttons = glfwGetJoystickButtons(_joy, &_buttons_count);
					_axes = glfwGetJoystickAxes(_joy, &_axes_count);
				}
Ejemplo n.º 14
0
		void update(EventQueue& _eventQueue)
		{
			int numButtons, numAxes;
			const unsigned char* buttons = glfwGetJoystickButtons(m_handle.idx, &numButtons);
			const float* axes = glfwGetJoystickAxes(m_handle.idx, &numAxes);

			if (NULL == buttons || NULL == axes)
			{
				return;
			}

			if (numAxes > GamepadAxis::Count)
			{
				numAxes = GamepadAxis::Count;
			}

			if (numButtons > Key::Count - Key::GamepadA)
			{
				numButtons = Key::Count - Key::GamepadA;
			}

			WindowHandle defaultWindow = { 0 };

			for (int ii = 0; ii < numAxes; ++ii)
			{
				GamepadAxis::Enum axis = translateGamepadAxis(ii);
				int32_t value = (int32_t) (axes[ii] * 32768.f);
				if (GamepadAxis::LeftY == axis || GamepadAxis::RightY == axis)
				{
					value = -value;
				}

				if (m_axes[ii] != value)
				{
					m_axes[ii] = value;
					_eventQueue.postAxisEvent(defaultWindow
						, m_handle
						, axis
						, value);
				}
			}

			for (int ii = 0; ii < numButtons; ++ii)
			{
				Key::Enum key = translateGamepadButton(ii);
				if (m_buttons[ii] != buttons[ii])
				{
					m_buttons[ii] = buttons[ii];
					_eventQueue.postKeyEvent(defaultWindow
						, key
						, 0
						, buttons[ii] != 0);
				}
			}
		}
Ejemplo n.º 15
0
bool Joystick::init(const int index_) {

        _id = index_;
        _name = glfwGetJoystickName(_id);
        _axes = glfwGetJoystickAxes(_id, &_axesNum);
        _polledButtons = glfwGetJoystickButtons(_id, &_buttonsNum);
        for (int i = 0; i < _buttonsNum; ++ i)
                _buttons.push_back(false);
        
	return true;
}
Ejemplo n.º 16
0
bool Controller::getB()
{
	if (!controllerPresent())
		return false;
	int count = 0;
	const unsigned char* buttons = glfwGetJoystickButtons(0, &count);
	/*for(int i = 0; i < count; i++)
	 if(buttons[i] > 0)
	 return true;*/
	return buttons[1];
}
Ejemplo n.º 17
0
//SGenum SG_EXPORT sgmCoreJoystickButtonSetState(void* joystick, SGbool* state)
SGenum SG_EXPORT sgmCoreJoystickButtonGetState(void* joystick, SGbool* state)
{
    if(joystick == NULL)
        return SG_OK; // SG_INVALID_VALUE
    Joystick* cjoystick = (Joystick*)joystick;

    glfwGetJoystickButtons(cjoystick->id, cjoystick->buttons, cjoystick->numbuttons);
    state = memcpy(state, cjoystick->buttons, cjoystick->numbuttons * sizeof(SGbool));

    return SG_OK;
}
Ejemplo n.º 18
0
void Joystick::update(float dt_) {
  (void)dt_;
        _axes = glfwGetJoystickAxes(_id, &_axesNum);
        _leftStick.x() = _axes[0];
        _leftStick.y() = _axes[1];
        _rightStick.x() = _axes[3];
        _rightStick.y() = _axes[4];

        _polledButtons = glfwGetJoystickButtons(_id, &_buttonsNum);
        for (int i = 0; i < _buttonsNum; ++ i)
                _buttons[i] = (_polledButtons[i] == GLFW_PRESS) ? true : false;
}
Ejemplo n.º 19
0
    bool Controller::isButtonDown(const int index, const int button)
    {
    #if defined(JOP_OS_DESKTOP)

        int count = 0;
        const unsigned char* buttons = glfwGetJoystickButtons(index, &count);

        return (button < count) ? buttons[button] == GLFW_PRESS : false;

    #elif defined(JOP_OS_ANDROID)
        return detail::ActivityState::get()->activeControllerButtons[button];

    #endif
    }
Ejemplo n.º 20
0
/*========================================================================
 * Retrieve joystick states
 *========================================================================*/
static void updateJoysticksState(void)
{
    int joy;

    for (joy = GLFW_JOYSTICK_1;  joy < GLFW_JOYSTICK_LAST + 1;  joy++)
    {
        printf("Updating information for joystick %d\n", joy);
        states[joy].present = glfwGetJoystickParam(joy, GLFW_PRESENT);
        if (states[joy].present == GL_TRUE)
        {
            states[joy].num_axes = glfwGetJoystickPos(joy, states[joy].axes, MAX_AXES);
            states[joy].num_buttons = glfwGetJoystickButtons(joy, states[joy].buttons, MAX_BUTTONS);
        }
    }
}
Ejemplo n.º 21
0
	void Joystick_Imp::RefreshInputState()
	{

		const float* ax = glfwGetJoystickAxes(m_connectId, &m_axesCount);
		for (int i = 0; i < m_axesCount; ++i)
		{
			m_currentAxes[i] = ax[i];
		}

		const unsigned char* btns = glfwGetJoystickButtons(m_connectId, &m_buttonsCount);
		for (int i = 0; i < m_buttonsCount; ++i)
		{
			m_preButtonHit[i] = m_currentButtonHit[i];
			m_currentButtonHit[i] = (bool)btns[i];
		}
	}
Ejemplo n.º 22
0
	bool Input::step()
	{
		INIT_ASSERT(Input);

		int count;

		for (unsigned i = 0; i < NUM_OF_KEYS; ++i)
		{
			keyState[i] = keyPress[i] > keyRelease[i];

			if (glfwGetKey(Window::instance().window, i) == GLFW_PRESS) keyPress[i]   = glfwGetTime();
			else														keyRelease[i] = glfwGetTime();
		}

		for (unsigned i = 0; i < NUM_OF_MOUSE_BTNS; ++i)
		{
			mouseState[i] = mousePress[i] > mouseRelease[i];

			if (glfwGetMouseButton(Window::instance().window, i) == GLFW_PRESS) mousePress[i]   = glfwGetTime();
			else																mouseRelease[i] = glfwGetTime();
		}

		for (unsigned i = 0; i < activeJoysticks; ++i)
		{
			for (unsigned j = 0; j < NUM_OF_JOY_BTNS; ++j)
			{
				joyState[i][j] = joyPress[i][j] > joyRelease[i][j];

				if (glfwGetJoystickButtons(i, &count)[j] == GLFW_PRESS) joyPress[i][j] = glfwGetTime();
				else													joyRelease[i][j] = glfwGetTime();
			}
		}

		double x, y;
		glfwGetCursorPos(Window::instance().window, &x, &y);

		mouseX = x;
		mouseY = y;

		for (unsigned i = 0; i < activeJoysticks; ++i)
			for (unsigned j = 0; j < NUM_OF_JOY_AXES; ++j)
				joyAxes[i][j] = glfwGetJoystickAxes(i, &count)[j];

		return false;
	}
Ejemplo n.º 23
0
	void _update() override {

		int countButtons;
		const unsigned char *buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_2, &countButtons);

		static bool reloaded = false;

		if (buttons[3] == 1 && !reloaded) {

			print_d("Reloading assets");
			flare::asset::reload();
		}

		if (buttons[3] == 0 && reloaded) {

			reloaded = false;
		}
	}
Ejemplo n.º 24
0
	//-----------------------------------------------------------------//
	void device::service(const bits_t& bits, const locator& poss)
	{
		bits_t b = bits;
		int joy = 0;
		if(glfwJoystickPresent(joy) == GL_TRUE) {
			int count;
			const float* axes = glfwGetJoystickAxes(joy, &count);
			for(int i = 0; i < count; ++i) {
				if(i == 1) {
					if(axes[i] > 0.5f) b.set(key::GAME_UP);
					else if(axes[i] < -0.5f) b.set(key::GAME_DOWN);
				} else if(i == 0) {
					if(axes[i] > 0.5f) b.set(key::GAME_RIGHT);
					else if(axes[i] < -0.5f) b.set(key::GAME_LEFT);
				}
			}
			const unsigned char* bl = glfwGetJoystickButtons(joy, &count);
			if(count > 16) count = 16;
			for(int i = 0; i < count; ++i) {
				if(bl[i] != 0) b.set(static_cast<key>(static_cast<int>(key::GAME_0) + i));
			}
		}

		b.set(key::STATE_CAPS_LOCK, level_.test(key::STATE_CAPS_LOCK));
		b.set(key::STATE_SCROLL_LOCK, level_.test(key::STATE_SCROLL_LOCK));
			  b.set(key::STATE_NUM_LOCK, level_.test(key::STATE_NUM_LOCK));

		positive_ =  b & ~level_;
		negative_ = ~b &  level_;

		if(positive_.test(key::CAPS_LOCK)) {
			b.flip(key::STATE_CAPS_LOCK);
		}
		if(positive_.test(key::SCROLL_LOCK)) {
			b.flip(key::STATE_SCROLL_LOCK);
		}
		if(positive_.test(key::NUM_LOCK)) {
			b.flip(key::STATE_NUM_LOCK);
		}

		level_ = b;

		locator_ = poss;
	}
Ejemplo n.º 25
0
 std::vector<JoystickState> GLFW_App::get_joystick_states() const
 {
     std::vector<JoystickState> ret;
     int count;
     for(int i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; i++)
     {
         if(!glfwJoystickPresent(i)) continue;
         
         const float *glfw_axis = glfwGetJoystickAxes(i, &count);
         std::vector<float> axis(glfw_axis, glfw_axis + count);
         
         const uint8_t *glfw_buttons = glfwGetJoystickButtons(i, &count);
         std::vector<uint8_t> buttons(glfw_buttons, glfw_buttons + count);
         
         std::string name(glfwGetJoystickName(i));
         ret.push_back(JoystickState(name, buttons, axis));
     }
     return ret;
 }
Ejemplo n.º 26
0
void CApplication::ProcessJoystickInput()
{
	if (g_aJoysticks.size() != MAX_JOYSTICKS)
		return;

	for (size_t i = 0; i < MAX_JOYSTICKS; i++)
	{
		CJoystick& oJoystick = g_aJoysticks[i];

		if (!oJoystick.m_bPresent)
			continue;

		static tvector<float> aflAxis;
		aflAxis.resize(oJoystick.m_aflAxis.size());
		glfwGetJoystickPos(i, &aflAxis[0], oJoystick.m_aflAxis.size());

		for (size_t j = 0; j < oJoystick.m_aflAxis.size(); j++)
		{
			if (aflAxis[j] != oJoystick.m_aflAxis[j])
				JoystickAxis(i, j, aflAxis[j], aflAxis[j]-oJoystick.m_aflAxis[j]);
		}

		oJoystick.m_aflAxis = aflAxis;

		static tvector<unsigned char> aiButtons;
		aiButtons.resize(oJoystick.m_iButtons);
		glfwGetJoystickButtons(i, &aiButtons[0], oJoystick.m_iButtons);

		for (size_t j = 0; j < oJoystick.m_iButtons; j++)
		{
			unsigned long long iButtonMask = (1<<j);
			if (aiButtons[j] == GLFW_PRESS && !(oJoystick.m_aiButtonStates&iButtonMask))
				JoystickButtonPress(i, MapJoystickKey(j));
			else if (aiButtons[j] == GLFW_RELEASE && (oJoystick.m_aiButtonStates&iButtonMask))
				JoystickButtonRelease(i, MapJoystickKey(j));

			if (aiButtons[j] == GLFW_PRESS)
				oJoystick.m_aiButtonStates |= iButtonMask;
			else
				oJoystick.m_aiButtonStates &= ~iButtonMask;
		}
	}
}
Ejemplo n.º 27
0
static void joystick_callback(int joy, int event)
{
    if (event == GLFW_CONNECTED)
    {
        int axisCount, buttonCount;

        glfwGetJoystickAxes(joy, &axisCount);
        glfwGetJoystickButtons(joy, &buttonCount);

        printf("%08x at %0.3f: Joystick %i (%s) was connected with %i axes and %i buttons\n",
               counter++, glfwGetTime(),
               joy,
               glfwGetJoystickName(joy),
               axisCount,
               buttonCount);
    }
    else
    {
        printf("%08x at %0.3f: Joystick %i was disconnected\n",
               counter++, glfwGetTime(), joy);
    }
}
Ejemplo n.º 28
0
 void Joystick::Update() {
   previous_axes = axes;
   previous_buttons = buttons;
   if (glfwJoystickPresent(joystick_id)) {
     int axis_count = 0;
     const float *axis_data = glfwGetJoystickAxes(joystick_id, &axis_count);
     CHECK_STATE(axis_count);
     CHECK_STATE(axis_data);
     for (auto i = 0; i < axis_count; ++i) {
       axes[static_cast<Axis>(i)] = axis_data[i];
     }
     int button_count = 0;
     const unsigned char *button_data = glfwGetJoystickButtons(joystick_id, &button_count);
     CHECK_STATE(button_count);
     CHECK_STATE(button_data);
     for (auto i = static_cast<int>(Button::kBegin); i < static_cast<int>(Button::kEnd); ++i) {
       buttons[static_cast<Button>(i)] = button_data[i];
     }
   }
   auto now = std::chrono::high_resolution_clock::now();
   dt = std::chrono::duration_cast<std::chrono::duration<float>>(now - last_update_time).count();
   last_update_time = now;
 }
///@brief Check out what joysticks we have and select a preferred one
bool OculusAppSkeleton::initJoysticks()
{
    for (int i=GLFW_JOYSTICK_1; i<GLFW_JOYSTICK_16; ++i)
    {
        const int present = glfwJoystickPresent(i);
        if (present == GL_TRUE)
        {
            /// Nostromo:                   6 axes, 24 buttons
            /// Gravis Gamepad Pro:         2 axes, 10 buttons
            /// Generic wireless dualshock: 4 axes, 12 buttons
            /// Eliminator Aftershock:      6 axes, 10 buttons
            int numAxes = 0;
            int numButs = 0;
            glfwGetJoystickAxes(i, &numAxes);
            glfwGetJoystickButtons(i, &numButs);
            printf("Joystick %d:  %d axes, %d buttons\n", i, numAxes, numButs);

            /// This just finds the first available joystick.
            if ( (numAxes == 2) && (numButs == 10))
            {
                preferredGamepadID = i;
                swapGamepadRAxes = false;
            }
            else if ( (numAxes == 6) && (numButs == 10))
            {
                preferredGamepadID = i;
                swapGamepadRAxes = false;
            }
            else if ( (numAxes == 4) && (numButs == 12))
            {
                preferredGamepadID = i;
                swapGamepadRAxes = true;
            }
        }
    }
    return true;
}
void ofxGLFWJoystick::lookForJoysticks(){

	int n = 0;
	for(int i = 0; i < GLFW_JOYSTICK_LAST; i++){
		if(glfwJoystickPresent(i)){
			joyData[i].available = true;
			string name = string(glfwGetJoystickName(i));
			if(name != joyData[i].name){
				joyData[i].name = name;
				ofLogNotice("ofxGLFWJoystick") << "Joystick Found at index " << i << ": '" << name << "'";
				joyData[i].axisData = glfwGetJoystickAxes(i, &joyData[i].numAxis);
				joyData[i].buttonData = glfwGetJoystickButtons(i, &joyData[i].numButtons);
			}
			n++;
		}else{
			if (joyData[i].name.size()){
				ofLogNotice("ofxGLFWJoystick") << "Joystick Lost at index " << i << ": '" << joyData[i].name << "'";
			}
			joyData[i].available = false;
			joyData[i].name = "";
		}
	}
	numJoysticks = n;
}