गेम कंट्रोलर लाइब्रेरी का इस्तेमाल करना

इनका इस्तेमाल करके अपने गेम में गेम कंट्रोलर की सुविधा जोड़ने के लिए, नीचे दिए गए फ़ंक्शन का इस्तेमाल करें गेम कंट्रोलर लाइब्रेरी का इस्तेमाल किया जा सकता है.

गेम कंट्रोलर लाइब्रेरी को शुरू करें और बंद करें

Paddleboat_init का इस्तेमाल करें फ़ंक्शन का इस्तेमाल करें.

Paddleboat_ErrorCode Paddleboat_init(JNIEnv *env, jobject jcontext)

Paddleboat_init में दो पैरामीटर इस्तेमाल होते हैं:

• JNIEnv की ओर पॉइंटर मौजूदा थ्रेड के साथ अटैच किया गया है
• एक jobject JNI ऑब्जेक्ट, Context डिराइव्ड क्लास. कोई भी Context डिराइव्ड क्लास ऑब्जेक्ट मान्य है. इसमें इनके अलावा, और भी चीज़ें शामिल हो सकती हैं Activity, NativeActivity, या GameActivity.

Paddleboat_init का शुल्क देकर, प्रॉडक्ट को लौटाया जा सकता है PADDLEBOAT_NO_ERROR अगर शुरू हो गया है, नहीं तो गड़बड़ी का सही कोड डालें वापस किया जाता है.

Paddleboat_isInitialized का इस्तेमाल करके, यह देखा जा सकता है कि कंट्रोलर लाइब्रेरी शुरू कर दी गई है. यह बूलियन दिखाता है वैल्यू. अगर सही है, तो यह एपीआई इस्तेमाल के लिए उपलब्ध है.

bool Paddleboat_isInitialized()

ऐप्लिकेशन को खत्म करने से पहले, Paddleboat_destroy फ़ंक्शन का इस्तेमाल करना होगा. यह फ़ंक्शन सिर्फ़ एक पैरामीटर, मौजूदा थ्रेड के साथ अटैच किए गए JNIEnv का पॉइंटर. Paddleboat_init को Paddleboat_destroy के बाद फिर से कॉल किया जा सकता है.

void Paddleboat_destroy(JNIEnv *env)

लाइफ़साइकल इवेंट की लाइब्रेरी को जानकारी दें

गेम कंट्रोलर लाइब्रेरी को गतिविधि की लाइफ़साइकल onStop और onStart इवेंट. कॉल करें Paddleboat_onStop और Paddleboat_onStart फ़ंक्शन आपके स्टॉप और स्टार्ट इवेंट हैंडलिंग कोड से जुड़े होते हैं. दोनों फ़ंक्शन को सिंगल पैरामीटर: मौजूदा थ्रेड से अटैच किए गए JNIEnv का पॉइंटर.

void Paddleboat_onStop(JNIEnv *env)
void Paddleboat_onStart(JNIEnv *env)

कंट्रोलर के स्टेटस कॉलबैक को रजिस्टर करना या हटाना

गेम कंट्रोलर की लाइब्रेरी, गेम की सूचना देने के लिए कंट्रोलर के स्टेटस कॉलबैक का इस्तेमाल करती है जब कोई कंट्रोलर कनेक्ट या डिसकनेक्ट होता है. यह सिर्फ़ एक कंट्रोलर के साथ काम करता है स्थिति कॉलबैक को एक बार में सबमिट कर सकते हैं.

• कंट्रोलर के स्टेटस का कॉलबैक रजिस्टर करने या पहले के किसी इवेंट को बदलने के लिए एक नए कॉलबैक फ़ंक्शन के साथ पंजीकृत कॉलबैक, तो Paddleboat_setControllerStatusCallback फ़ंक्शन का इस्तेमाल करें.
• रजिस्टर किए गए किसी मौजूदा कॉलबैक को हटाने के लिए, NULL या nullptr को पास करें.
• userData पैरामीटर, उपयोगकर्ता के तय किए गए डेटा का एक वैकल्पिक पॉइंटर है. कॉन्टेंट बनाने userData पैरामीटर को कॉलबैक फ़ंक्शन को पास किया जाएगा. यह पॉइंटर को आंतरिक रूप से तब तक बनाए रखा जाता है, जब तक कि उसे अगला कॉल नहीं किया जाता Paddleboat_setControllerStatusCallback.

void Paddleboat_setControllerStatusCallback(Paddleboat_ControllerStatusCallback
  statusCallback, void *userData)

कॉलबैक फ़ंक्शन का फ़ंक्शन सिग्नेचर यह है:

typedef void (*Paddleboat_ControllerStatusCallback)(
  const int32_t controllerIndex,
  const Paddleboat_ControllerStatus controllerStatus,
  void *userData)

पैरामीटर	ब्यौरा
controllerIndex	उस कंट्रोलर का इंडेक्स जिसने कॉलबैक. यह वैल्यू, 0 और के बीच की होगी PADDLEBOAT_MAX_CONTROLLERS - 1
controllerStatus	का Enum मान PADDLEBOAT_CONTROLLER_JUST_CONNECTED या PADDLEBOAT_CONTROLLER_JUST_DISCONNECTED.
userData	उपयोगकर्ता के लिए वैकल्पिक पॉइंटर (शून्य हो सकता है) इसे अंतिम बार किए गए कॉल द्वारा दर्ज किया गया डेटा Paddleboat_setControllerStatusCallback.

गेम कंट्रोलर लाइब्रेरी के अपडेट फ़ंक्शन को कॉल करें

गेम कंट्रोलर लाइब्रेरी का अपडेट फ़ंक्शन, Paddleboat_update , को हर गेम फ़्रेम के लिए एक बार कॉल किया जाना चाहिए. आम तौर पर, यह फ़्रेम की शुरुआत के पास होना चाहिए. फ़ंक्शन एक पैरामीटर लेता है, जो किJNIEnv मौजूदा थ्रेड.

void Paddleboat_update(JNIEnv *env)

इवेंट प्रोसेस करना

इनपुट इवेंट पाते समय, आपके गेम को वह उन्हें जांच के लिए गेम कंट्रोलर लाइब्रेरी को भेज देगा. द गेम कंट्रोलर लाइब्रेरी यह आकलन करती है कि क्या कोई इनपुट इवेंट, मैनेज किए जा रहे किसी इवेंट से जुड़ा है डिवाइस. मैनेज किए जा रहे डिवाइसों के इवेंट प्रोसेस किए जाते हैं और उनका इस्तेमाल किया जाता है.

गेम कंट्रोलर की लाइब्रेरी दो तरह के इनपुट इवेंट के साथ काम करती है: AInputEvents और GameActivity इनपुट इवेंट.

AइनपुटEvent प्रोसेसिंग

आपके गेम को AInputEvents को कॉल करके फ़ॉरवर्ड करना चाहिए Paddleboat_processInputEvent से जोड़ा जा सकता है.

int32_t Paddleboat_processInputEvent(const AInputEvent *event)

अगर इवेंट को अनदेखा किया गया था और 1 को अनदेखा किया गया था, तो Paddleboat_processInputEvent 0 दिखाएगा अगर इवेंट को गेम कंट्रोलर लाइब्रेरी से प्रोसेस और इस्तेमाल किया गया था.

GameActivity इवेंट प्रोसेसिंग

अगर आपका गेम GameActivity का इस्तेमाल करता है, तो फ़ॉरवर्ड करें GameActivityKeyEvent और कॉल करके GameActivityMotionEvent इवेंट देखें Paddleboat_processGameActivityKeyInputEvent या Paddleboat_processGameActivityMotionInputEvent से जोड़ा जा सकता है.

int32_t Paddleboat_processGameActivityKeyInputEvent(const void *event,
                                                    const size_t eventSize)
int32_t Paddleboat_processGameActivityMotionInputEvent(const void *event,
                                                       const size_t eventSize)

पैरामीटर	ब्यौरा
event	GameActivityKeyEvent या इसके आधार पर, GameActivityMotionEvent का स्ट्रक्चर किस फ़ंक्शन को कॉल किया जा रहा है.
eventSize	इवेंट का साइज़ बाइट में event पैरामीटर में पास किया गया स्ट्रक्चर.

अगर इवेंट को अनदेखा किया गया है, तो दोनों फ़ंक्शन 0 रिटर्न करेंगे और अगर इवेंट1 गेम कंट्रोलर लाइब्रेरी की मदद से प्रोसेस और इस्तेमाल किया जाता है.

GameActivity फ़ंक्शन के लिए, ऐक्टिव मोशन ऐक्सिस की जानकारी देने के लिए, इसका इस्तेमाल करके GameActivityPointerAxes_enableAxis फ़ंक्शन. कॉन्टेंट बनाने Paddleboat_getActiveAxisMask कॉल, कनेक्ट किए गए वर्तमान सक्रिय गति अक्ष का बिटमास्क लौटाता है कंट्रोलर.

uint64_t Paddleboat_getActiveAxisMask()

इसे मैनेज करने के उदाहरण के लिए, गेम कंट्रोलर लाइब्रेरी का सैंपल देखें जो GameActivity का इस्तेमाल करता है. यह सैंपल, ऐक्टिव ऐक्सिस मास्क को पोल करता है और सही जानकारी देता है नए ऐक्सिस का इस्तेमाल करने पर, GameActivity. इसे इसमें लागू किया जाता है NativeEngine::CheckForNewAxis() फ़ंक्शन का इस्तेमाल करना होगा.

void NativeEngine::CheckForNewAxis() {
    // Tell GameActivity about any new axis ids so it reports
    // their events
    const uint64_t activeAxisIds = Paddleboat_getActiveAxisMask();
    uint64_t newAxisIds = activeAxisIds ^ mActiveAxisIds;
    if (newAxisIds != 0) {
        mActiveAxisIds = activeAxisIds;
        int32_t currentAxisId = 0;
        while(newAxisIds != 0) {
            if ((newAxisIds & 1) != 0) {
                LOGD("Enable Axis: %d", currentAxisId);
                GameActivityPointerAxes_enableAxis(currentAxisId);
            }
            ++currentAxisId;
            newAxisIds >>= 1;
        }
    }
}

कंट्रोलर के बारे में जानें

गेम कंट्रोलर लाइब्रेरी, किसी खास जानकारी को रेफ़र करने के लिए इंडेक्स वैल्यू का इस्तेमाल करती है कंट्रोलर. इंडेक्स की मान्य वैल्यू की रेंज 0 से लेकर PADDLEBOAT_MAX_CONTROLLERS - 1. कॉन्टेंट बनाने Paddleboat_getControllerStatus फ़ंक्शन किसी खास कंट्रोलर इंडेक्स की स्थिति को तय करता है.

Paddleboat_ControllerStatus Paddleboat_getControllerStatus(
  const int32_t controllerIndex)

कनेक्ट किए गए कंट्रोलर से जानकारी पढ़ने के तीन फ़ंक्शन हैं.

• Paddleboat_getControllerName फ़ंक्शन, कंट्रोलर डिवाइस का नाम लेता है.
• Paddleboat_getControllerInfo फ़ंक्शन, कंट्रोलर डिवाइस के बारे में डेटा हासिल करता है.
• Paddleboat_getControllerData फ़ंक्शन, कंट्रोलर के इनपुट की मौजूदा स्थिति को हासिल करता है.

नियंत्रक का नाम

Paddleboat_getControllerName function दो इनपुट पैरामीटर लेता है: कंट्रोलर इंडेक्स, बफ़र साइज़, और पॉइंटर कंट्रोलर के नाम वाली स्ट्रिंग को सेव करने के लिए बफ़र. नाम स्ट्रिंग C स्ट्रिंग, जिसमें UTF-8 एन्कोडिंग का इस्तेमाल किया गया है. डिवाइस का नाम अंदरूनी तौर पर लिया जाता है InputDevice.getName() का इस्तेमाल करके.

अगर Paddleboat_getControllerName नाम को फ़ेच कर लेता है, तो यह वापस आ जाता है PADDLEBOAT_NO_ERROR. ऐसा न करने पर, एक गड़बड़ी का सही कोड दिखाया जाता है.

Paddleboat_ErrorCode Paddleboat_getControllerName(const int32_t controllerIndex,
                                                  const size_t bufferSize,
                                                  char *controllerName);

पैरामीटर	ब्यौरा
controllerIndex	उस कंट्रोलर का इंडेक्स जिसने कॉलबैक. यह वैल्यू, 0 और के बीच की होगी PADDLEBOAT_MAX_CONTROLLERS - 1
bufferSize	पास किए गए बफ़र का साइज़ बाइट में controllerName, नाम वाली स्ट्रिंग होगी. बफ़र में फ़िट करने के लिए ज़रूरी होने पर काट-छांट की जाती है.
controllerName	bufferSize बाइट के बफ़र का पॉइंटर कंट्रोलर का नाम सेव करने के लिए. नाम में इसे UTF-8 एन्कोडिंग का इस्तेमाल करके, सी स्ट्रिंग के तौर पर सेव किया जाना चाहिए.

कंट्रोलर डिवाइस की जानकारी

Paddleboat_getControllerInfo function में दो इनपुट पैरामीटर इस्तेमाल किए जाते हैं: कंट्रोलर इंडेक्स और Paddleboat_Controller_Info स्ट्रक्चर के पॉइंटर.

अगर Paddleboat_Controller_Info में डेटा अपने-आप भर गया था, Paddleboat_getControllerInfo, PADDLEBOAT_NO_ERROR दिखाता है. अगर ऐसा नहीं होता है, तो गड़बड़ी का सही कोड दिखाया जाता है.

Paddleboat_ErrorCode Paddleboat_getControllerInfo(const int32_t controllerIndex,
  Paddleboat_Controller_Info *controllerInfo)

Paddleboat_Controller_Info स्ट्रक्चर में डिवाइस से जुड़ी खास जानकारी मौजूद है कंट्रोलर के बारे में जानकारी.

typedef struct Paddleboat_Controller_Info {
    uint32_t controllerFlags;
    int32_t controllerNumber;
    int32_t vendorId;
    int32_t productId;
    int32_t deviceId;
    Paddleboat_Controller_Thumbstick_Precision leftStickPrecision;
    Paddleboat_Controller_Thumbstick_Precision rightStickPrecision;
} Paddleboat_Controller_Info;

typedef struct Paddleboat_Controller_Thumbstick_Precision {
    float stickFlatX;
    float stickFlatY;
    float stickFuzzX;
    float stickFuzzY;
} Paddleboat_Controller_Thumbstick_Precision;

कई स्ट्रक्चर में, इन वैल्यू से ली गई वैल्यू का इस्तेमाल किया जाता है InputDevice कंट्रोलर:

controllerNumber    -   InputDevice.getControllerNumber()
vendorId              - InputDevice.getVendorId()
productId             - InputDevice.getProductId()
deviceId              - InputDevice.getId()

• stickFlat वैल्यू, सेंटर फ़्लैट पोज़िशन की सीमा दिखाती है. यह वैल्यू मुख्य रूप से, डिफ़ॉल्ट सेंटर 'डेड-ज़ोन' का हिसाब लगाने में काम आती है तारीख सेल्फ़-सेंटरिंग डिवाइस.
• stickFuzz वैल्यू से पता चलता है कि गड़बड़ी सहन की जा सकती है या मौजूदा शोर और डिवाइस की संवेदनशीलता की वजह से, वैल्यू असल वैल्यू से अलग हो सकती है सीमित कर दिया है.

किसी भी डाइमेंशन में, दोनों वैल्यू को नॉर्मलाइज़ किया हुआ होता है. यह वैल्यू 1.0 की ज़्यादा से ज़्यादा तय होती है.

controllerFlags सदस्य में अलग-अलग बिटमास्क का मिला-जुला सेट शामिल है फ़्लैग और मल्टीपल-बिट कॉम्बिनेशन वैल्यू का इस्तेमाल करते हैं.

controllerFlags के साथ लॉजिकल AND को लागू किया जा रहा है PADDLEBOAT_CONTROLLER_LAYOUT_MASK से नतीजे के तौर पर एक ऐसी वैल्यू मिलती है जिसे Paddleboat_ControllerButtonLayout ईनम. यह ईनम, बटन के बारे में बताता है कंट्रोलर, आइकोनोग्राफ़ी और लेआउट का इस्तेमाल करता है.

enum Paddleboat_ControllerButtonLayout {
    //  Y
    // X B
    //  A
    PADDLEBOAT_CONTROLLER_LAYOUT_STANDARD = 0,
    //  △
    // □ ○
    //  x
    PADDLEBOAT_CONTROLLER_LAYOUT_SHAPES = 1,
    //  X
    // Y A
    //  B
    PADDLEBOAT_CONTROLLER_LAYOUT_REVERSE = 2,
    // X Y R1 L1
    // A B R2 L2
    PADDLEBOAT_CONTROLLER_LAYOUT_ARCADE_STICK = 3,
    PADDLEBOAT_CONTROLLER_LAYOUT_MASK = 3
};

नीचे दिए गए कॉन्सटेंट, क्षमता बिट को तय करते हैं. यह पता लगाने के लिए कि कोई कंट्रोलर किसी खास क्षमता के साथ काम करता है, तो उससे जुड़े लॉजिकल AND को लागू करें controllerFlags के ख़िलाफ़ लगातार. शून्य के अलावा किसी नतीजे का मतलब है कि सुविधा कंट्रोलर के साथ काम करता है.

PADDLEBOAT_CONTROLLER_FLAG_TOUCHPAD

अगर यह फ़्लैग बिट सेट है, तो कंट्रोलर में इंटिग्रेट किया गया टचपैड है. अगर टचपैड दबाया गया है, कंट्रोलर PADDLEBOAT_BUTTON_TOUCHPAD बिट को सेट करता है Paddleboat_Controller_Data.buttonsDown फ़ील्ड में.

PADDLEBOAT_CONTROLLER_FLAG_VIRTUAL_MOUSE

अगर यह फ़्लैग बिट सेट है, तो कंट्रोलर पॉइंटर डिवाइस को एम्युलेट कर देता है. कॉन्टेंट बनाने Paddleboat_Controller_Data स्ट्रक्चर का virtualPointer सदस्य है वर्चुअल पॉइंटर के मौजूदा निर्देशांक से अपने-आप भर जाता है.

नियंत्रक डेटा

Paddleboat_getControllerData फ़ंक्शन दो इनपुट पैरामीटर लेता है: कंट्रोलर इंडेक्स और Paddleboat_Controller_Data स्ट्रक्चर के पॉइंटर. अगर आपने Paddleboat_Controller_Data में डेटा अपने-आप भर जाता है, Paddleboat_getControllerInfo, PADDLEBOAT_NO_ERROR दिखाता है. अगर ऐसा नहीं होता है, तो गड़बड़ी का सही कोड दिखाया जाता है.

Paddleboat_ErrorCode Paddleboat_getControllerData(const int32_t controllerIndex,
  Paddleboat_Controller_Data *controllerData)

Paddleboat_Controller_Data स्ट्रक्चर में मौजूदा कंट्रोल इनपुट शामिल है कंट्रोलर की वैल्यू दी गई होती हैं.

typedef struct Paddleboat_Controller_Data {
    uint64_t timestamp;
    uint32_t buttonsDown;
    Paddleboat_Controller_Thumbstick leftStick;
    Paddleboat_Controller_Thumbstick rightStick;
    float triggerL1;
    float triggerL2;
    float triggerR1;
    float triggerR2;
    Paddleboat_Controller_Pointer virtualPointer;
} Paddleboat_Controller_Data;

typedef struct Paddleboat_Controller_Pointer {
    float pointerX;
    float pointerY;
} Paddleboat_Controller_Pointer;

typedef struct Paddleboat_Controller_Thumbstick {
    float stickX;
    float stickY;
} Paddleboat_Controller_Thumbstick;

मान की रेंज

इनपुट प्रकार	मान की सीमा
थंबटिक ऐक्सिस	-1.0 से 1.0
ट्रिगर	0.0 से 1.0
वर्चुअल पॉइंटर	0.0 से विंडो की चौड़ाई/ऊंचाई (पिक्सल में)

स्ट्रक्चर की जानकारी

स्ट्रक्चर का सदस्य	ब्यौरा
buttonsDown	बिट-प्रति-बटन बिटफ़ील्ड अरे. बटन बिटमास्क कॉन्सटेंट की जानकारी paddlebot.h में दी जाती है. हेडर फ़ाइल है और PADDLEBOAT_BUTTON_.
timestamp.	सबसे हाल के कंट्रोलर इनपुट का टाइमस्टैंप इवेंट. टाइमस्टैंप माइक्रोसेकंड है, क्योंकि क्लॉक epoch का इस्तेमाल करें.
virtualPointer	वर्चुअल पॉइंटर की जगह. यह ऑफ़र सिर्फ़ तब मान्य होगा, जब PADDLEBOAT_CONTROLLER_FLAG_VIRTUAL_MOUSE फ़्लैग controllerFlags में सेट है, नहीं तो होगा 0.0, 0.0.