added controller vibration support through libshake

Makefile

@@ -13,7 +13,7 @@ RM = rm -f
 
 
 # Add SDL dependency
-LDFLAGS +=-lSDL_gfx -lSDL_image -lSDL_mixer $(shell $(SDL_CONFIG) --libs) -lGLESv1_CM -lEGL
+LDFLAGS +=-lSDL_gfx -lSDL_image -lSDL_mixer $(shell $(SDL_CONFIG) --libs) -lGLESv1_CM -lEGL -lshake
 CFLAGS +=$(shell $(SDL_CONFIG) --cflags) -g -DGCW
 
 #LDFLAGS +=-lSDL_gfx -lSDL_image -lSDL_mixer $(shell sdl-config --libs) -lGL

Makefile_PC

@@ -12,7 +12,7 @@ RM = rm -f
 
 
 # Add SDL dependency
-LDFLAGS +=-lSDL_gfx -lSDL_image -lSDL_mixer $(shell $(SDL_CONFIG) --libs) -lGLESv1_CM -lEGL -lX11
+LDFLAGS +=-lSDL_gfx -lSDL_image -lSDL_mixer $(shell $(SDL_CONFIG) --libs) -lGLESv1_CM -lEGL -lX11 -lshake
 CFLAGS +=$(shell $(SDL_CONFIG) --cflags) -g -DGCW -DPC
 
 #Pandora Mode

opk_build/libshake.so

@@ -0,0 +1 @@
+./libshake.so.1

opk_build/libshake.so.0

@@ -0,0 +1 @@
+./libshake.so.1

zcore.c

@@ -6,6 +6,7 @@
 #include <GL/gl.h>
 #include <SDL/SDL.h>
 #include <SDL/SDL_opengl.h>
+#include "zlext.h"
 SDL_Surface *screen = NULL;
 #endif
 

zlext.c

@@ -1,5 +1,59 @@
 #include "vars.h"
 
+
+#if defined(GCW) || defined(PC32)
+#include "zlext/shake.h"
+#include <unistd.h>
+Shake_Device *device;
+Shake_Effect effect, effect2;
+int id, id2;
+void zlInitVibe(void){
+    Shake_Init();
+    if(Shake_NumOfDevices()>0){
+        device = Shake_Open(0);
+        Shake_InitEffect(&effect, SHAKE_EFFECT_PERIODIC);
+        effect.u.periodic.waveform              = SHAKE_PERIODIC_SINE;
+        effect.u.periodic.period                = 0.1*0x100;
+        effect.u.periodic.magnitude             = 0x7000;//7083,7FFF
+        effect.u.periodic.envelope.attackLength = 0x0;//100
+        effect.u.periodic.envelope.attackLevel  = 50;
+        effect.u.periodic.envelope.fadeLength   = 0x0;//100
+        effect.u.periodic.envelope.fadeLevel    = 50;
+        effect.direction                        = 0x4000;
+        effect.length                           = 400;
+        effect.delay                            = 0;
+        id = Shake_UploadEffect(device, &effect);
+
+	Shake_InitEffect(&effect2, SHAKE_EFFECT_PERIODIC);
+        effect2.u.periodic.waveform              = SHAKE_PERIODIC_SINE;
+        effect2.u.periodic.period                = 0.1*0x100;
+        effect2.u.periodic.magnitude             = 0x5000;//7083,7FFF
+        effect2.u.periodic.envelope.attackLength = 0x0;//100
+        effect2.u.periodic.envelope.attackLevel  = 50;
+        effect2.u.periodic.envelope.fadeLength   = 0x0;//100
+        effect2.u.periodic.envelope.fadeLevel    = 50;
+        effect2.direction                        = 0x4000;
+        effect2.length                           = 150;
+        effect2.delay                            = 0;
+        id2 = Shake_UploadEffect(device, &effect);
+    }
+}
+void zlProcVibe(void){
+    if (vibro>-64){
+	if(vibro>=100)
+		Shake_Play(device, id);
+	//if(vibro>=88)
+	else
+	        Shake_Play(device, id2);
+    }
+}
+void zlShutDownVibe(void){
+    Shake_EraseEffect(device, id);
+    Shake_Close(device);
+    Shake_Quit();
+}
+#endif
+
 #ifdef GP2XCAANOO
 //Vibration
 
@@ -211,6 +265,9 @@ void wizhack(void)
 
 void zlextinit(void)
 {
+#if defined(GCW) || defined(PC32)
+    zlInitVibe();
+#endif
 #ifdef GP2XCAANOO
     zlInitVibe();
     zlInitGSensor();
@@ -249,6 +306,11 @@ void zlextframe(void)
     else vibro=-80;
 
 #endif
+
+#if defined(GCW) || defined(PC32)
+    if (configdata[10]) zlProcVibe();
+#endif
+
 }
 
 void zlextshutdown(void)
@@ -257,4 +319,7 @@ void zlextshutdown(void)
     zlShutDownVibe();
     zlShutDownGSensor();
 #endif
+#if defined(GCW) || defined(PC32)
+    zlShutDownVibe();
+#endif
 }

zlext/shake.h

@@ -0,0 +1,178 @@
+#ifndef _SHAKE_H_
+#define _SHAKE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define SHAKE_MAJOR_VERSION 0
+#define SHAKE_MINOR_VERSION 3
+#define SHAKE_PATCH_VERSION 0
+
+#define SHAKE_ENVELOPE_ATTACK_LENGTH_MAX	0x7FFF
+#define SHAKE_ENVELOPE_FADE_LENGTH_MAX		0x7FFF
+#define SHAKE_ENVELOPE_ATTACK_LEVEL_MAX		0x7FFF
+#define SHAKE_ENVELOPE_FADE_LEVEL_MAX		0x7FFF
+
+#define SHAKE_RUMBLE_STRONG_MAGNITUDE_MAX	0x7FFF
+#define SHAKE_RUMBLE_WEAK_MAGNITUDE_MAX		0x7FFF
+
+#define SHAKE_PERIODIC_PERIOD_MAX		0x7FFF
+#define SHAKE_PERIODIC_MAGNITUDE_MIN		(-0x8000)
+#define SHAKE_PERIODIC_MAGNITUDE_MAX		0x7FFF
+#define SHAKE_PERIODIC_OFFSET_MIN		(-0x8000)
+#define SHAKE_PERIODIC_OFFSET_MAX		0x7FFF
+#define SHAKE_PERIODIC_PHASE_MAX		0x7FFF
+
+#define SHAKE_CONSTANT_LEVEL_MIN		(-0x8000)
+#define SHAKE_CONSTANT_LEVEL_MAX		0x7FFF
+
+#define SHAKE_RAMP_START_LEVEL_MIN		(-0x8000)
+#define SHAKE_RAMP_START_LEVEL_MAX		0x7FFF
+#define SHAKE_RAMP_END_LEVEL_MIN		(-0x8000)
+#define SHAKE_RAMP_END_LEVEL_MAX		0x7FFF
+
+#define SHAKE_EFFECT_ID_MIN			(-0x0001)
+#define SHAKE_EFFECT_DIRECTION_MAX		0xFFFE
+#define SHAKE_EFFECT_LENGTH_MAX			0x7FFF
+#define SHAKE_EFFECT_DELAY_MAX			0x7FFF
+
+typedef enum Shake_Status
+{
+	SHAKE_ERROR	= -1,
+	SHAKE_OK	= 0,
+} Shake_Status;
+
+typedef enum Shake_Bool
+{
+	SHAKE_FALSE	= 0,
+	SHAKE_TRUE	= 1
+} Shake_Bool;
+
+typedef enum Shake_ErrorCode
+{
+	SHAKE_EC_UNSET,
+	SHAKE_EC_SUPPORT,
+	SHAKE_EC_DEVICE,
+	SHAKE_EC_EFFECT,
+	SHAKE_EC_QUERY,
+	SHAKE_EC_ARG,
+	SHAKE_EC_TRANSFER
+} Shake_ErrorCode;
+
+struct Shake_Device;
+typedef struct Shake_Device Shake_Device;
+
+typedef enum Shake_PeriodicWaveform
+{
+	SHAKE_PERIODIC_SQUARE = 0,
+	SHAKE_PERIODIC_TRIANGLE,
+	SHAKE_PERIODIC_SINE,
+	SHAKE_PERIODIC_SAW_UP,
+	SHAKE_PERIODIC_SAW_DOWN,
+	SHAKE_PERIODIC_CUSTOM,
+	SHAKE_PERIODIC_COUNT
+} Shake_PeriodicWaveform;
+
+typedef enum Shake_EffectType
+{
+	/* Force feedback effects */
+	SHAKE_EFFECT_RUMBLE = 0,
+	SHAKE_EFFECT_PERIODIC,
+	SHAKE_EFFECT_CONSTANT,
+	SHAKE_EFFECT_SPRING,
+	SHAKE_EFFECT_FRICTION,
+	SHAKE_EFFECT_DAMPER,
+	SHAKE_EFFECT_INERTIA,
+	SHAKE_EFFECT_RAMP,
+	SHAKE_EFFECT_COUNT
+} Shake_EffectType;
+
+typedef struct Shake_Envelope
+{
+	uint16_t attackLength;
+	uint16_t attackLevel;
+	uint16_t fadeLength;
+	uint16_t fadeLevel;
+} Shake_Envelope;
+
+typedef struct Shake_EffectRumble
+{
+	uint16_t strongMagnitude;
+	uint16_t weakMagnitude;
+} Shake_EffectRumble;
+
+typedef struct Shake_EffectPeriodic
+{
+	Shake_PeriodicWaveform waveform;
+	uint16_t period;
+	int16_t magnitude;
+	int16_t offset;
+	uint16_t phase;
+	Shake_Envelope envelope;
+} Shake_EffectPeriodic;
+
+typedef struct Shake_EffectConstant
+{
+	int16_t level;
+	Shake_Envelope envelope;
+} Shake_EffectConstant;
+
+typedef struct Shake_EffectRamp
+{
+	int16_t startLevel;
+	int16_t endLevel;
+	Shake_Envelope envelope;
+} Shake_EffectRamp;
+
+typedef struct Shake_Effect
+{
+	Shake_EffectType type;
+	int16_t id;
+	uint16_t direction;
+	uint16_t length;
+	uint16_t delay;
+	union
+	{
+		Shake_EffectRumble rumble;
+		Shake_EffectPeriodic periodic;
+		Shake_EffectConstant constant;
+		Shake_EffectRamp ramp;
+	} u;
+} Shake_Effect;
+
+/* libShake functions */
+Shake_Status Shake_Init();
+void Shake_Quit();
+int Shake_NumOfDevices();
+Shake_Device *Shake_Open(unsigned int id);
+Shake_Status Shake_Close(Shake_Device *dev);
+int Shake_DeviceId(Shake_Device *dev);
+const char *Shake_DeviceName(Shake_Device *dev);
+int Shake_DeviceEffectCapacity(Shake_Device *dev);
+Shake_Bool Shake_QueryEffectSupport(Shake_Device *dev, Shake_EffectType type);
+Shake_Bool Shake_QueryWaveformSupport(Shake_Device *dev, Shake_PeriodicWaveform waveform);
+Shake_Bool Shake_QueryGainSupport(Shake_Device *dev);
+Shake_Bool Shake_QueryAutocenterSupport(Shake_Device *dev);
+Shake_Status Shake_SetGain(Shake_Device *dev, int gain);
+Shake_Status Shake_SetAutocenter(Shake_Device *dev, int autocenter);
+Shake_Status Shake_InitEffect(Shake_Effect *effect, Shake_EffectType type);
+int Shake_UploadEffect(Shake_Device *dev, Shake_Effect *effect);
+Shake_Status Shake_EraseEffect(Shake_Device *dev, int id);
+Shake_Status Shake_Play(Shake_Device *dev, int id);
+Shake_Status Shake_Stop(Shake_Device *dev, int id);
+
+void Shake_SimpleRumble(Shake_Effect *effect, float strongPercent, float weakPercent, float secs);
+void Shake_SimplePeriodic(Shake_Effect *effect, Shake_PeriodicWaveform waveform, float forcePercent, float attackSecs, float sustainSecs, float fadeSecs);
+void Shake_SimpleConstant(Shake_Effect *effect, float forcePercent, float attackSecs, float sustainSecs, float fadeSecs);
+void Shake_SimpleRamp(Shake_Effect *effect, float startForcePercent, float endForcePercent, float attackSecs, float sustainSecs, float fadeSecs);
+
+Shake_ErrorCode Shake_GetErrorCode();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _SHAKE_H_ */