//JOYC.C for D1_3Dfx and D1OpenGL
//D1_3Dfx is a Win32 executable using Glide and DirectX 3
//D1OpenGL is a Win32 executable using OpenGL and DirectX 3
//This joystick code should run on DirectInput 2 and higher
//We are not using DirectX 5 for now, since we want to stay compatible to the HH-loved Windows NT :).
//So ForceFeedback is not supported

//Notes:
// 1) Windows DirectX supports up to 7 axes, D1/DOS only 4, so we needed to increase the number to 7 at several points
//    Also JOY_ALL_AXIS must be (1+2+4+8+16+32+64) in JOY.H file
// 2) Windows DirectX supports up to 32 buttons. So far we however only support 4. Adding support for more should be however easily possible.
// 3) _enable and _disable are not needed
// 4) joy_bogus_reading is not needed, so all calls are just removed
// 5) The joystick query goes over the DirectInputs function
//    MMRESULT joyGetPosEx(UINT uJoyID, LPJOYINFOEX pji);
//    All functions reading over BIOS, including the ASM code are removed



/*
THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.  
COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
*/

/*
Modifications by Heiko Herrmann
Later modified by Owen Evans to work with D1X (3/7/99)
*/


#define _WIN32_OS		//HH

#include <windows.h>	//HH
#include <mmsystem.h>	//HH
#include <stdlib.h>
#include <stdio.h>

#include "types.h"
#include "joy.h"
#include "timer.h"
#include "args.h"

#define my_hwnd g_hWnd // D1X compatibility
extern HWND g_hWnd;

char joy_installed = 0;
char joy_present = 0;

typedef struct Button_info {
	ubyte		ignore;
	ubyte		state;
	ubyte		last_state;
	int		timedown;
	ubyte		downcount;
	ubyte		upcount;
} Button_info;

typedef struct Joy_info {
	int			joyid;
	ubyte			present_mask;
	ubyte			slow_read;
	int			max_timer;
	int			read_count;
	ubyte			last_value;
	Button_info	buttons[MAX_BUTTONS];
        int                     axis_min[JOY_NUM_AXES];    //changed 
        int                     axis_center[JOY_NUM_AXES]; //changed --orulz
        int                     axis_max[JOY_NUM_AXES];    //changed 
} Joy_info;

Joy_info joystick;


int joy_deadzone = 0;

void joy_get_cal_vals(int *axis_min, int *axis_center, int *axis_max)
{
	int i;

        for (i=0; i<JOY_NUM_AXES; i++)             {       //changed - orulz
		axis_min[i] = joystick.axis_min[i];
		axis_center[i] = joystick.axis_center[i];
		axis_max[i] = joystick.axis_max[i];
	}
}

void joy_set_cal_vals(int *axis_min, int *axis_center, int *axis_max)
{
	int i;

        for (i=0; i<JOY_NUM_AXES; i++)             {       //changed - orulz
		joystick.axis_min[i] = axis_min[i];
		joystick.axis_center[i] = axis_center[i];
		joystick.axis_max[i] = axis_max[i];
	}
}

ubyte joy_get_present_mask()	{
	return joystick.present_mask;
}

void joy_set_timer_rate(int max_value )	{
	joystick.max_timer = max_value;
}

int joy_get_timer_rate()	{
	return joystick.max_timer;
}

void joy_flush()	{
	int i;

	if (!joy_installed) return;

	for (i=0; i<MAX_BUTTONS; i++ )	{
		joystick.buttons[i].ignore = 0;
		joystick.buttons[i].state = 0;	
		joystick.buttons[i].timedown = 0;	
		joystick.buttons[i].downcount = 0;	
		joystick.buttons[i].upcount = 0;	
	}

}


//Repalces joy_handler
//Since Windows calls us directly, we have to get our time difference since last time ourselves
//while in DOS we got it with the paramter ticks_this_time
LRESULT joy_handler32(HWND hWnd, UINT joymsg, UINT wParam, LPARAM lParam)
{
	DWORD time_diff, time_now;
	static DWORD time_last = 0xffffffff;
	
	Button_info *button;
	int i;
	int state=0;
	DWORD value=0;

	if (!joy_installed) return 1;
	if (time_last == 0xffffffff) {
		time_last = timer_get_fixed_seconds();
		return 0;
	}

	if (joymsg==MM_JOY1MOVE)
	{
		JOYINFOEX	joy;

		memset(&joy, 0, sizeof(joy));
		joy.dwSize = sizeof(joy);
		joy.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOV;
		if (joyGetPosEx(joystick.joyid, &joy)!=JOYERR_NOERROR) {
			return 1;
		}
		value = joy.dwButtons;
	}

	time_now = timer_get_fixed_seconds();
	if (time_now < time_last) {
		time_last = abs(time_now-time_last);
	}
	time_diff = time_now - time_last;

	for (i = 0; i < MAX_BUTTONS; i++)
	{
		button = &joystick.buttons[i];
		
		if (!button->ignore) {
			if ( i < (MAX_BUTTONS-4) )
				state = (value >> i) & 1;
			else
				state = 0;

			if ( button->last_state == state )	{
				if (state) {
					button->timedown += time_diff;	//ticks_this_time;
				}
			} else {
				if (state)	{
					button->downcount += state;
					button->state = 1;
				} else {	
					button->upcount += button->state;
					button->state = 0;
				}
				button->last_state = state;
			}
		}
	}

	time_last = time_now;
	return 0;
}		


//Begin section modified 3/7/99 - Owen Evans

ubyte joy_read_raw_buttons()
{
	JOYINFOEX joy;
        int i;

        if (!joy_present)
		return 0; 
	
	memset(&joy, 0, sizeof(joy));
	joy.dwSize = sizeof(joy);
        joy.dwFlags = JOY_RETURNBUTTONS | JOY_RETURNPOVCTS | JOY_USEDEADZONE;
	
        if (joyGetPosEx(joystick.joyid, &joy)!=JOYERR_NOERROR)
		return 0;

        for (i = 0; i < MAX_BUTTONS; i++) {
                joystick.buttons[i].last_state = joystick.buttons[i].state;
                joystick.buttons[i].state = (joy.dwButtons >> i) & 0x1;
                if (!joystick.buttons[i].last_state && joystick.buttons[i].state) {
                        joystick.buttons[i].timedown = timer_get_fixed_seconds();
                        joystick.buttons[i].downcount++;
                }
        }

        /* Hat stuff */

        if (joy.dwPOV != JOY_POVCENTERED)
         {
           joystick.buttons[19].state = (joy.dwPOV < JOY_POVRIGHT || joy.dwPOV > JOY_POVLEFT);
           joystick.buttons[15].state = (joy.dwPOV < JOY_POVBACKWARD && joy.dwPOV > JOY_POVFORWARD);
           joystick.buttons[11].state = (joy.dwPOV < JOY_POVLEFT && joy.dwPOV > JOY_POVRIGHT);
           joystick.buttons[7].state = (joy.dwPOV > JOY_POVBACKWARD);
         }

        return (ubyte)joy.dwButtons;
}

//end changed section - OE


ubyte joystick_read_raw_axis( ubyte mask, int * axis )
{
	JOYINFOEX	joy;
	ubyte read_masks = 0;

        axis[0] = 0; axis[1] = 0; //orulz: 1=x 2=y 3=r 4=z 5=u 6=v
        axis[2] = 0; axis[3] = 0;
	axis[4] = 0; axis[5] = 0; //HH: Added support for axes R and U
	
	if (!joy_installed) {
		return 0;
	}
	memset(&joy, 0, sizeof(joy));
	joy.dwSize = sizeof(joy);
	joy.dwFlags = JOY_RETURNALL | JOY_USEDEADZONE;
	if (joyGetPosEx(joystick.joyid, &joy)!=JOYERR_NOERROR) {
		return 0;
	}
			
	mask &= joystick.present_mask;			// Don't read non-present channels
	if ( mask==0 )	{
		return 0;		// Don't read if no stick connected.
	}

	if (mask & JOY_1_X_AXIS) { axis[0] = joy.dwXpos; read_masks |= JOY_1_X_AXIS; }
	if (mask & JOY_1_Y_AXIS) { axis[1] = joy.dwYpos; read_masks |= JOY_1_Y_AXIS; }
//orulz:
//        if (mask & JOY_1_Z_AXIS) { axis[2] = joy.dwZpos; read_masks |= JOY_1_Z_AXIS; }
//        if (mask & JOY_1_POV)    { axis[3] = joy.dwPOV;  read_masks |= JOY_1_POV;    }
//        if (mask & JOY_1_R_AXIS) { axis[4] = joy.dwRpos; read_masks |= JOY_1_R_AXIS; }
//        if (mask & JOY_1_U_AXIS) { axis[5] = joy.dwUpos; read_masks |= JOY_1_U_AXIS; }
//        if (mask & JOY_1_V_AXIS) { axis[6] = joy.dwVpos; read_masks |= JOY_1_V_AXIS; }
        if (mask & JOY_1_R_AXIS) { axis[2] = joy.dwRpos; read_masks |= JOY_1_R_AXIS; }
        if (mask & JOY_1_Z_AXIS) { axis[3] = joy.dwZpos; read_masks |= JOY_1_Z_AXIS; }
        if (mask & JOY_1_U_AXIS) { axis[4] = joy.dwZpos; read_masks |= JOY_1_U_AXIS; }
        if (mask & JOY_1_V_AXIS) { axis[5] = joy.dwUpos; read_masks |= JOY_1_V_AXIS; }

	return read_masks;
}

int hh_average(int val1, int val2)
{
	return abs(val1-val2)/2;
}

int joy_init(int joyid) //HH: added joyid parameter
{
	int i;
        int temp_axis[JOY_NUM_AXES];       //changed - orulz
	JOYCAPS pjc;

	if (FindArg( "-nojoystick" ))
		return 0;

	atexit(joy_close);	//HH: we are a bit lazy :). Errors are ignored, so we are even double-lazy :)

	joy_flush();
	memset(&joystick, 0, sizeof(joystick));

	for (i=0; i<MAX_BUTTONS; i++)
		joystick.buttons[i].last_state = 0;

	if ( !joy_installed )   {
                joy_present = 0;
                joy_installed = 1;
                joystick.max_timer = 65536;
                joystick.read_count = 0;
                joystick.last_value = 0;
	}


	joystick.present_mask = JOY_ALL_AXIS;		// Assume they're all present
        joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, temp_axis );

	if ( joystick.present_mask & 3 )
		joy_present = 1;
	else
		joy_present = 0;

	
	//HH: Main Win32 joystick initialization, incl. reading cal. stuff

	if (joyGetDevCaps(joyid, &pjc, sizeof(pjc))!=JOYERR_NOERROR) {
		return 0;
	}

	if (joySetThreshold(joyid, pjc.wXmax/256)!=JOYERR_NOERROR) {
		return 0;
	}
	
	if (joySetCapture(my_hwnd, joyid, JOY_POLL_RATE, FALSE)!=JOYERR_NOERROR) {
		return 0;
	}

        joystick.max_timer      = pjc.wPeriodMax;
	joystick.axis_min[0]	= pjc.wXmin;
	joystick.axis_min[1]	= pjc.wYmin;
//orulz:
//        joystick.axis_min[2]    = pjc.wZmin;
//        //HH: joystick.axis_min[3]  = pov-stuff
//        joystick.axis_min[4]    = pjc.wRmin;
//        joystick.axis_min[5]    = pjc.wUmin;
//        joystick.axis_min[6]    = pjc.wVmin;
        joystick.axis_min[2]    = pjc.wRmin;
        joystick.axis_min[3]    = pjc.wZmin;
        joystick.axis_min[4]    = pjc.wUmin;
        joystick.axis_min[5]    = pjc.wVmin;

	joystick.axis_max[0]	= pjc.wXmax;
	joystick.axis_max[1]	= pjc.wYmax;
//orulz:
//        joystick.axis_max[2]    = pjc.wZmax;
//        //HH: joystick.axis_max[3]  = pov-stuff
//        joystick.axis_max[4]    = pjc.wRmax;
//        joystick.axis_max[5]    = pjc.wUmax;
//        joystick.axis_max[6]    = pjc.wVmax;
        joystick.axis_max[2]    = pjc.wRmax;
        joystick.axis_max[3]    = pjc.wZmax;
        joystick.axis_max[4]    = pjc.wUmax;
        joystick.axis_max[5]    = pjc.wVmax;

        joystick.axis_center[0]	= hh_average(pjc.wXmax,pjc.wXmin);
	joystick.axis_center[1]	= hh_average(pjc.wYmax,pjc.wYmin);
//orulz:
//        joystick.axis_center[2] = hh_average(pjc.wZmax,pjc.wZmin);
//        joystick.axis_center[3] = JOY_POVCENTERED;
//        joystick.axis_center[4] = hh_average(pjc.wRmax,pjc.wRmin);
//        joystick.axis_center[5] = hh_average(pjc.wUmax,pjc.wUmin);
//        joystick.axis_center[6] = hh_average(pjc.wVmax,pjc.wVmin);
        joystick.axis_center[2] = hh_average(pjc.wRmax,pjc.wRmin);
        joystick.axis_center[3] = hh_average(pjc.wZmax,pjc.wZmin);
        joystick.axis_center[4] = hh_average(pjc.wUmax,pjc.wUmin);
        joystick.axis_center[5] = hh_average(pjc.wVmax,pjc.wVmin);

	joystick.present_mask = JOY_1_X_AXIS | JOY_1_Y_AXIS;
	if (pjc.wCaps & JOYCAPS_HASZ)	joystick.present_mask |= JOY_1_Z_AXIS;
//        if (pjc.wCaps & JOYCAPS_HASPOV) joystick.present_mask |= JOY_1_POV;
	if (pjc.wCaps & JOYCAPS_HASR)	joystick.present_mask |= JOY_1_R_AXIS;
	if (pjc.wCaps & JOYCAPS_HASU)	joystick.present_mask |= JOY_1_U_AXIS;
	if (pjc.wCaps & JOYCAPS_HASV)	joystick.present_mask |= JOY_1_V_AXIS;

	return joy_present;
}


void joy_close()
{
	if (!joy_installed) return;
	joyReleaseCapture(joystick.joyid); //HH: added to release joystick from the application. We ignore errors here
	joy_installed = 0;
}


void joy_set_ul()	
{
	joystick.present_mask = JOY_ALL_AXIS;		// Assume they're all present
        joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_min );

	if ( joystick.present_mask & 3 )
		joy_present = 1;
	else
		joy_present = 0;
}

void joy_set_lr()	
{
	joystick.present_mask = JOY_ALL_AXIS;		// Assume they're all present
        joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_max );

	if ( joystick.present_mask & 3 )
		joy_present = 1;
	else
		joy_present = 0;
}

void joy_set_cen() 
{
	joystick.present_mask = JOY_ALL_AXIS;		// Assume they're all present
        joystick.present_mask = joystick_read_raw_axis( JOY_ALL_AXIS, joystick.axis_center );

	if ( joystick.present_mask & 3 )
		joy_present = 1;
	else
		joy_present = 0;
}

void joy_set_cen_fake(int channel)	
{ }


int joy_get_scaled_reading( int raw, int axn )	
{
 int x, d;

  // Make sure it's calibrated properly.
   if ( joystick.axis_center[axn] - joystick.axis_min[axn] < 128 )
    return 0; //HH: had to increase to 128
   if ( joystick.axis_max[axn] - joystick.axis_center[axn] < 128 )
    return 0; //HH: had to increase to 128
    
   if (!(joystick.present_mask & (1<<axn))) return 0;//fixes joy config bug where it'll always set an axis you don't even have. - 2000/01/14 Matt Mueller

  raw -= joystick.axis_center[axn];

   if ( raw < 0 )
    d = joystick.axis_center[axn]-joystick.axis_min[axn];
   else
    d = joystick.axis_max[axn]-joystick.axis_center[axn];


   if ( d )
    x = (raw << 7) / d;
   else 
    x = 0;


   if ( x < -128 ) x = -128;
   if ( x > 127 ) x = 127;

//added on 4/13/99 by Victor Rachels to add deadzone control
  d =  (joy_deadzone) * 6;
   if ((x > (-1*d)) && (x < d))
    x = 0;
//end this section addition -VR

	return x;
}

void joy_get_pos( int *x, int *y )	
{
	ubyte flags;
        int axis[JOY_NUM_AXES];

	if ((!joy_installed)||(!joy_present)) { *x=*y=0; return; }

	flags=joystick_read_raw_axis( JOY_1_X_AXIS+JOY_1_Y_AXIS, axis );

	if ( flags & JOY_1_X_AXIS )
		*x = joy_get_scaled_reading( axis[0], 0 );
	else
		*x = 0;

	if ( flags & JOY_1_Y_AXIS )
		*y = joy_get_scaled_reading( axis[1], 1 );
	else
		*y = 0;
}

ubyte joy_read_stick( ubyte masks, int *axis )	
{
	ubyte flags;
        int raw_axis[JOY_NUM_AXES];

	if ((!joy_installed)||(!joy_present)) { 
		axis[0] = 0; axis[1] = 0;
		axis[2] = 0; axis[3] = 0;
                axis[4] = 0; axis[5] = 0; 
		return 0;  
	}

	flags=joystick_read_raw_axis( masks, raw_axis );

	if ( flags & JOY_1_X_AXIS )
		axis[0] = joy_get_scaled_reading( raw_axis[0], 0 );
	else
		axis[0] = 0;

	if ( flags & JOY_1_Y_AXIS )
		axis[1] = joy_get_scaled_reading( raw_axis[1], 1 );
	else
		axis[1] = 0;

        if ( flags & JOY_1_R_AXIS )
                axis[2] = joy_get_scaled_reading( raw_axis[2], 2 );
	else
                axis[2] = 0;

        if ( flags & JOY_1_Z_AXIS )
                axis[3] = joy_get_scaled_reading( raw_axis[3], 3 );
	else
		axis[3] = 0;

	if ( flags & JOY_1_U_AXIS )
                axis[4] = joy_get_scaled_reading( raw_axis[4], 4);
	else
                axis[4] = 0;

	if ( flags & JOY_1_V_AXIS )
                axis[5] = joy_get_scaled_reading( raw_axis[5], 5 );
	else
                axis[5] = 0;


	return flags;
}

int joy_get_btns()	
{
	if ((!joy_installed)||(!joy_present)) return 0;

	return joy_read_raw_buttons();
}


//Begin section modified 3/7/99 - Owen Evans

void joy_get_btn_down_cnt( int *btn0, int *btn1 )
{
	if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }

        joy_get_btns();

	*btn0 = joystick.buttons[0].downcount;
	joystick.buttons[0].downcount = 0;
	*btn1 = joystick.buttons[1].downcount;
	joystick.buttons[1].downcount = 0;
}

int joy_get_button_state( int btn )	
{    
	if ((!joy_installed)||(!joy_present)) return 0;
	if ( btn >= MAX_BUTTONS ) return 0;

        joy_get_btns();

        return joystick.buttons[btn].state;
}

int joy_get_button_up_cnt( int btn ) 
{
	int count;

	if ((!joy_installed)||(!joy_present)) return 0;

	if ( btn >= MAX_BUTTONS ) return 0;

	count = joystick.buttons[btn].upcount;
	joystick.buttons[btn].upcount = 0;

	return count;
}

int joy_get_button_down_cnt( int btn ) 
{
	int count;

	if ((!joy_installed)||(!joy_present)) return 0;
	if ( btn >= MAX_BUTTONS ) return 0;

        joy_get_btns();

	count = joystick.buttons[btn].downcount;
	joystick.buttons[btn].downcount = 0;

	return count;
}

fix joy_get_button_down_time( int btn ) 
{
        fix count;

        if ((!joy_installed)||(!joy_present)) return 0;
	if ( btn >= MAX_BUTTONS ) return 0;

        joy_get_btns();

        if (joystick.buttons[btn].state) {
                count = timer_get_fixed_seconds() - joystick.buttons[btn].timedown;
                joystick.buttons[btn].timedown = 0;
        } else count = 0;
        
        return count;
}

//end changed section - OE


void joy_get_btn_up_cnt( int *btn0, int *btn1 ) 
{
	if ((!joy_installed)||(!joy_present)) { *btn0=*btn1=0; return; }

	*btn0 = joystick.buttons[0].upcount;
	joystick.buttons[0].upcount = 0;
	*btn1 = joystick.buttons[1].upcount;
	joystick.buttons[1].upcount = 0;
}

void joy_set_btn_values( int btn, int state, fix timedown, int downcount, int upcount )
{
	joystick.buttons[btn].ignore = 1;
	joystick.buttons[btn].state = state;
	joystick.buttons[btn].timedown = fixmuldiv( timedown, 1193180, 65536 );
	joystick.buttons[btn].downcount = downcount;
	joystick.buttons[btn].upcount = upcount;
}

void joy_poll()
{
}