എങ്ങനെ ലെയർ, ഫ്രണ്ട്, ഗ്രാഫിക്സ് ഫ്രണ്ട് എന്നിവ കൊണ്ടുവരുക

കൊറോണ SDK ഉപയോഗിച്ച് ഗ്രാഫിക്സിനെ കൈകാര്യം ചെയ്യുക

കൊറോണ SDK യിൽ ഗ്രാഫിക്സ് സൃഷ്ടിക്കുന്നതും കൈകാര്യം ചെയ്യുന്നതും നിയന്ത്രിക്കുന്നതും പ്രധാന ഘടകം പ്രദർശന വസ്തുവാണ്. ഒരു ഫയൽ ഒരു ഇമേജ് പ്രദർശിപ്പിക്കാൻ ഈ വസ്തു ഉപയോഗിക്കുവാൻ മാത്രമല്ല, ഒരുപക്ഷേ പ്രധാനമായും, നിങ്ങളുടെ ചിത്രങ്ങൾ ഒന്നിച്ച് ഗ്രൂപ്പുചെയ്യാൻ ഇത് അനുവദിക്കുന്നു. ഇത് ഒരേസമയം സ്ക്രീനിന് ചുറ്റും ഒരു ഗ്രാഫിക്സ് ഗണിതവും പരസ്പരം മുകളിലെ ഗ്രേറ്റർ ഗ്രാഫിക്സും നീക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നിങ്ങളുടെ പ്രോജക്ടിലെ ഗ്രാഫിക്കൽ വസ്തുക്കളെ ഓർഗനൈസ് ചെയ്യുന്നതിന് ഡിസ്പ്ലേ ഗ്രൂപ്പുകൾ ഉപയോഗിക്കുന്നതിന്റെ അടിസ്ഥാനങ്ങളെ ഈ ട്യൂട്ടോറിയൽ നിങ്ങളെ പഠിപ്പിക്കും. ഇത് രണ്ട് വ്യത്യസ്ത പാളികൾ സൃഷ്ടിക്കുന്നതിലൂടെ തെളിയിക്കപ്പെടുന്നു, ഒന്ന് സാധാരണ സ്ക്രീനെ പ്രതിനിധീകരിക്കുന്നു, മറ്റൊന്ന് മുകളിൽ ഒരു മോഡേൽ ലെയറെ പ്രതിനിധീകരിക്കുന്നു. ഗ്രാഫിക്സ് layering കൂടാതെ, മുഴുവൻ മോഡൽ ഗ്രൂപ്പും നീക്കുന്നതിന് ഞങ്ങൾ പരിവർത്തന ഒബ്ജക്റ്റ് ഉപയോഗിക്കും.

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ എങ്ങനെ മാർക്കറ്റ് ചെയ്യാം

കുറിപ്പ്: ഈ ട്യൂട്ടോറിയലിനൊപ്പം പിന്തുടരാൻ, നിങ്ങൾക്ക് രണ്ട് ചിത്രങ്ങൾ ആവശ്യമാണ്: image1.png and image2.png. ഇവ നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന ചിത്രങ്ങളായിരിക്കാം, പക്ഷേ 100 പിക്സലുകളിൽ നിങ്ങൾക്ക് ചിത്രങ്ങളുണ്ടെങ്കിൽ നിങ്ങൾക്ക് ട്യൂട്ടോറിയൽ മികച്ചതായിരിക്കും. ഇമേജുകൾക്ക് എന്താണ് സംഭവിക്കുന്നതെന്ന് എളുപ്പത്തിൽ കാണാൻ അനുവദിക്കും.

ആരംഭിക്കുന്നതിന്, ഞങ്ങൾ main.lua എന്ന പേരിൽ ഒരു പുതിയ ഫയൽ തുറക്കുകയും ഞങ്ങളുടെ കോഡ് നിർമ്മിക്കുന്നത് ആരംഭിക്കുകയും ചെയ്യും:

displayMain = display.newGroup (); displayFirst = display.newGroup (); displaySecond = display.newGroup (); global_move_x = display.contentWidth / 5;

കോഡിന്റെ ഈ ഭാഗം ഞങ്ങളുടെ ui ലൈബ്രറി സജ്ജീകരിച്ച് പ്രദർശന ഗ്രൂപ്പുകൾ വഴി പ്രദർശിപ്പിക്കുന്നു: displayMine, displayFirst and displaySecond. ഞങ്ങളുടെ ഗ്രാഫിക്സുകൾ ആദ്യം ലേയർ ചെയ്യുന്നതിനും അവയെ നീക്കം ചെയ്യുന്നതിനും ഞങ്ങൾ ഇത് ഉപയോഗിക്കും. പ്രദർശന വീതിയുടെ 20% വരെ global_move_x വേരിയബിൾ സജ്ജമാക്കിയിരിക്കുന്നതിനാൽ നമ്മൾ പ്രസ്ഥാനത്തെ കാണും.

ഫങ്ഷൻ സജ്ജീകരണം സ്ക്രീൻ () പ്രദർശനംമെയ്ൻ: ചേർക്കുക (ഡിസ്പ്ഫർ); displayMain: insert (displaySecond); displayFirst: toFront (); displaySecond: toFront (); പ്രാദേശിക പശ്ചാത്തലം = display.newImage ("image1.png", 0,0); displayFirst: തിരുകുക (പശ്ചാത്തലം); പ്രാദേശിക പശ്ചാത്തലം = display.newImage ("image2.png", 0,0); displaySecond: insert (background); അവസാനിക്കുന്നു

SetupScreen ഫങ്ഷൻ പ്രധാന ഡിസ്പ്ലേ ഗ്രൂപ്പിലേക്ക് ഡിസ്പ്ലേ ഗ്രൂപ്പുകൾ ചേർക്കുന്നത് എങ്ങനെ എന്ന് കാണിക്കുന്നു. ഞങ്ങൾ മറ്റൊരു ഗ്രാഫിക് ലെയറുകൾ സ്ഥാപിക്കാൻ tofront () ഫങ്ഷൻ ഉപയോഗിക്കും, അവസാനമായി പ്രഖ്യാപിച്ചിട്ടുള്ള എല്ലാ സമയത്തും ഞങ്ങൾ ആഗ്രഹിക്കുന്ന പാളിയാണ്.

ഈ ഉദാഹരണത്തിൽ, displaySecond ഗ്രൂപ്പിനു താഴെയായി മാറുന്നതിനാൽ ഡിസ്പ്ലേയെ മുന്നണിയിലേക്ക് കൊണ്ടുവരാൻ യഥാർത്ഥത്തിൽ ആവശ്യമില്ല, എന്നാൽ ഓരോ ഡിസ്പ്ലേ ഗ്രൂപ്പിന്റെയും പ്രത്യേകതയായിരിക്കും ഇത്. മിക്ക പ്രോജക്ടുകളും രണ്ട് ലേയറിൽ കൂടുതൽ വരും.

ഓരോ ഗ്രൂപ്പിനും ഞങ്ങൾ ഒരു ഇമേജ് ചേർത്തിട്ടുണ്ട്. ഞങ്ങൾ അപ്ലിക്കേഷൻ ആരംഭിക്കുമ്പോൾ, രണ്ടാമത്തെ ചിത്രം ആദ്യ ചിത്രത്തിന്റെ മുകളിലായിരിക്കണം.

ഫംഗ്ഷൻ സ്ക്രീൻ ലേയർ () പ്രദർശിപ്പിക്കുക First: toFront (); അവസാനിക്കുന്നു

ഡിസ്പ്ലേ ആദ്യത്തെ ഗ്രൂപ്പിലെ displaySecond ഗ്രൂപ്പ് ഉപയോഗിച്ച് ഞങ്ങൾ ഇതിനകം ഗ്രാഫിക്സ് ലേയാക്കിയിട്ടുണ്ട്. ഈ ഫംഗ്ഷൻ പ്രദർശനത്തിലേക്ക് നീങ്ങുന്നു.

ഫങ്ഷൻ നീക്കുകഓൺ () പ്രദർശനംസെസെൻഡ്.x = ഡിസ്പ്ലേസ് സെഡന്റ്. x + ഗ്ലോബൽ_മോവ്_ക്സ്; അവസാനിക്കുന്നു

സ്ക്രീനിന്റെ വീതിയുടെ 20% വലതുവശത്തെ രണ്ടാമത്തെ ചിത്രത്തെ നീക്കം ചെയ്യുന്നു. ഈ ഫങ്ഷനെ വിളിക്കുമ്പോൾ, displaySecond ഗ്രൂപ്പ് displayfirst group ന് ശേഷമായിരിക്കും.

ഫംഗ്ഷൻ moveTwo () ഡിസ്പ്ലേ Main.x = displayMain.x + global_move_x; അവസാനിക്കുന്നു

നീക്കം രണ്ടു് സ്ക്രീനിന്റെ വീതി 20% വഴി വലതുവശത്തേക്ക് രണ്ടു് ചിത്രങ്ങളും നീക്കും. എന്നിരുന്നാലും, ഓരോ ഗ്രൂപ്പിലേയും വ്യക്തിഗതമായി നീക്കുന്നതിന് പകരം, അവയെ ഒരേ സമയം രണ്ടായി നീക്കുന്നതിന് പ്രദർശന മെയിൻ ഗ്രൂപ്പ് ഉപയോഗിക്കും. ഒന്നിലധികം ഡിസ്പ്ലേ ഗ്രൂപ്പുകളുള്ള ഒരു ഡിസ്പ്ലേ ഗ്രൂപ്പിന് ഒന്നിലധികം ഗ്രാഫിക്സ് ഉപയോഗിച്ച് ഒരേസമയം എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നതിന്റെ ഒരു മികച്ച ഉദാഹരണമാണിത്.

സജ്ജീകരണം സ്ക്രീൻ (); timer.performWithDelay (1000, screenLayer); timer.performWithDelay (2000, നീക്കം ഒൺ); timer.performWithDelay (3000, moveTwo);

ഞങ്ങൾ ഈ പ്രവർത്തനങ്ങൾ പ്രവർത്തിക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നത് എന്ന് ഈ അവസാനത്തെ കോഡ് തെളിയിക്കുന്നു. ആപ്ലിക്കേഷൻ സമാരംഭിച്ചതിന് ശേഷം ഓരോ സെക്കന്റിലും ഫങ്ഷനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനായി ടൈമർ.പ്രൊഫോർ വൈറ്റ്ഡെലേ ഫംഗ്ഷൻ ഉപയോഗിക്കും. ഈ ഫംഗ്ഷനെക്കുറിച്ച് നിങ്ങൾക്ക് പരിചയമില്ലെങ്കിൽ, ആദ്യത്തെ വേരിയബിൾ മില്ലിസെക്കൻഡിൽ അവതരിപ്പിക്കുന്ന താമസം, രണ്ടാമത്തേത്, ആ കാലതാമസത്തിനുശേഷമാണ് പ്രവർത്തിക്കേണ്ടത്.

നിങ്ങൾ ആപ്ലിക്കേഷൻ സമാരംഭിക്കുമ്പോൾ, image1.png മുകൾഭാഗത്ത് image2.png ഉണ്ടായിരിക്കണം. ScreenLayer ഫംഗ്ഷൻ ഫ്രെയിമിലേക്ക് ഇമേജ് 1.png എത്തും. Move1.png ചിത്രത്തിലെ ചിത്രത്തിൽ നിന്ന് image2.png നീക്കം ചെയ്യപ്പെടും, ഒപ്പം move2 രണ്ട് ഫങ്ഷനും അവസാനമാക്കും.

ഒരു സ്ലോ ഐപാഡ് പരിഹരിക്കുക എങ്ങനെ

ഈ ഗ്രൂപ്പുകളിൽ ഓരോന്നും ഡസൻ കണക്കിന് ചിത്രങ്ങൾ ഉണ്ടായിരിക്കുമെന്നത് ഓർക്കേണ്ടത് പ്രധാനമാണ്. MoveTwo ഫംഗ്ഷൻ ഒരു കോഡിന്റെ വരിയിൽ രണ്ട് ചിത്രങ്ങളും നീക്കി, ഒരു ഗ്രൂപ്പിലെ എല്ലാ ഇമേജുകളും ഗ്രൂപ്പിനു നൽകിയിരിക്കുന്ന ആജ്ഞകൾ എടുക്കും.

സാങ്കേതികമായി, ഡിസ്പ്ലേ മെയിൻ ഗ്രൂപ്പിൽ ഉൾക്കൊള്ളുന്ന ഡിസ്പ്ലേ ഗ്രൂപ്പുകളും ഇമേജുകളും ഉണ്ടായിരിക്കാം. എന്നിരുന്നാലും, മികച്ച സംഘാടനത്തിനായി ഒരു ഇമേജ് ഇല്ലാതെ മറ്റ് ഗ്രൂപ്പുകൾക്ക് വേണ്ടി കണ്ടെയ്നറുകൾ ഡിസ്പ്ലേ ക്രിയകൾ പോലെയുള്ള ചില ഗ്രൂപ്പുകളെ അനുവദിക്കുക എന്നത് നല്ല രീതിയാണ്.

ഈ ട്യൂട്ടോറിയൽ ഡിസ്പ്ലേ ഒബ്ജക്റ്റിന്റെ ഉപയോഗം ഉപയോഗിക്കുന്നു. പ്രദർശന വസ്തുവിനെക്കുറിച്ച് കൂടുതലറിയുക.

എങ്ങനെ തുടങ്ങണം? ഐപാഡ് അപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കൽ