ఎలా లేయర్, ఫ్రంట్ గ్రాఫిక్స్ తరలించు మరియు తీసుకురండి

గ్రాఫిక్స్ మానిప్యులేట్ కు కరోనా SDK ఉపయోగించి

కరోనా SDK లో గ్రాఫిక్స్ని సృష్టించడం, నిర్వహించడం మరియు నిర్వహించడం యొక్క ముఖ్య భాగం ప్రదర్శన వస్తువు. ఒక వస్తువు నుండి ఒక చిత్రాన్ని ప్రదర్శించడానికి ఈ వస్తువును ఉపయోగించడం మాత్రమే కాదు, బహుశా అంతే ముఖ్యమైనది, ఇది మీ చిత్రాలను కలిపేందుకు అనుమతిస్తుంది. ఇది ఒకదానికొకటి పైభాగంలోని గ్రాఫిక్స్ మొత్తం సెట్టింగులను మరియు పొర గ్రాఫిక్స్ను ఒకేసారి తరలించడానికి మిమ్మల్ని అనుమతిస్తుంది.

మీ ట్యుటోరియల్ మీ ప్రాజెక్ట్లోని గ్రాఫికల్ వస్తువులని నిర్వహించడానికి ప్రదర్శన సమూహాలను ఉపయోగించగల ప్రాథమికాలను మీకు నేర్పుతుంది. రెండు వేర్వేరు పొరలను సృష్టించడం ద్వారా ఇది ప్రదర్శించబడుతుంది, సాధారణ స్క్రీన్కు ప్రాతినిధ్యం వహిస్తుంది మరియు మరొకదానిపై మోడల్ పొరను సూచిస్తుంది. గ్రాఫిక్స్ పొరపాటు కాకుండా, మొత్తం మోడల్ సమూహాన్ని తరలించడానికి మేము పరివర్తన వస్తువును కూడా ఉపయోగిస్తాము.

మీ అనువర్తనాన్ని ఎలా మార్కెట్ చేయాలి

గమనిక: ఈ ట్యుటోరియల్తో పాటు అనుసరించడానికి, మీరు రెండు చిత్రాలు అవసరం: image1.png మరియు image2.png. ఇవి మీరు ఎంచుకునే చిత్రాలను కలిగి ఉంటాయి, కానీ మీరు 100 పిక్సల్స్ ద్వారా 100 పిక్సల్స్ చిత్రాలను కలిగి ఉంటే ట్యుటోరియల్ ఉత్తమంగా పని చేస్తుంది. ఇది చిత్రాలకు ఏమి జరుగుతుందో సులభంగా చూడడానికి మిమ్మల్ని అనుమతిస్తుంది.

ప్రారంభించడానికి, మేము main.lua అని పిలువబడే కొత్త ఫైల్ను తెరవాలి మరియు మా కోడ్ను నిర్మించడాన్ని ప్రారంభించాము:

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

కోడ్ యొక్క ఈ విభాగం మా UI లైబ్రరీని సెట్ చేస్తుంది మరియు ప్రదర్శన సమూహాల ద్వారా ప్రకటిస్తుంది: displayMain, displayFirst and displaySecond. మేము వీటిని మొదటిసారిగా మా గ్రాఫిక్స్కి వాడతాము మరియు వాటిని తరలించండి. ప్రదర్శన యొక్క వెడల్పులో global_move_x వేరియబుల్ 20% వరకు సెట్ చేయబడుతుంది, కనుక మనం ఉద్యమం చూడవచ్చు.

ఫంక్షన్ setupScreen () ప్రదర్శనమ్యాన్: ఇన్సర్ట్ (displayFirst); displayMain: ఇన్సర్ట్ (displaySecond); displayFirst: toFront (); displaySecond: toFront (); స్థానిక నేపథ్యం = display.newImage ("image1.png", 0,0); displayFirst: ఇన్సర్ట్ (నేపథ్యం); స్థానిక నేపథ్యం = display.newImage ("image2.png", 0,0); displaySecond: ఇన్సర్ట్ (నేపథ్యం); ముగింపు

సెటప్ స్క్రీన్ ఫంక్షన్ ప్రధాన ప్రదర్శన సమూహంలో ప్రదర్శన సమూహాలను ఎలా జోడించాలో ప్రదర్శిస్తుంది. మేము వేరొక గ్రాఫిక్ పొరలను ఏర్పాటు చేసేందుకు toFront () ఫంక్షన్ను కూడా వాడతాము, చివరిగా మేము పొరపాటున ఉన్న పొరను చివరిగా ప్రకటించాము.

ఈ ఉదాహరణలో, displaySecond సమూహం క్రింద ఉండటానికి డిఫాల్ట్గా ఉంటుంది, కానీ ప్రతి ప్రదర్శిత సమూహాన్ని స్పష్టంగా ఉంచడం యొక్క అలవాటు పొందడానికి ఇది మంచిది, ఇది ప్రదర్శనను ముందుకి తరలించడానికి నిజంగా అవసరం లేదు. చాలా ప్రాజెక్టులు రెండు కంటే ఎక్కువ పొరలతో ముగుస్తాయి.

మేము ప్రతి సమూహానికి ఒక చిత్రాన్ని జోడించాము. మేము అనువర్తనం ప్రారంభించినప్పుడు, రెండవ చిత్రం మొదటి చిత్రం పైన ఉండాలి.

ఫంక్షన్ screenLayer () displayFirst: toFront (); ముగింపు

మేము మా గ్రాఫిటీని displaySecond సమూహంలో ప్రదర్శించాము. ఈ ఫంక్షన్ ప్రదర్శనకు తరలించబడుతుంది.

ఫంక్షన్ moveOne () displaySecond.x = displaySecond.x + global_move_x; ముగింపు

కదలికఒక ఫంక్షన్ రెండవ వెడల్పును కుడి వైపున వెడల్పు 20% వెడల్పుగా కదులుతుంది. మేము ఈ ఫంక్షన్ కాల్ చేసినప్పుడు, displaySecond సమూహం displayFirst సమూహం వెనుక ఉంటుంది.

ఫంక్షన్ moveTwo () displayMain.x = displayMain.x + global_move_x; ముగింపు

MoveTwo ఫంక్షన్ రెండు చిత్రాలను కుడివైపున వెడల్పు 20% వెడల్పుకు తరలించబడుతుంది. ఏదేమైనా, ప్రతి సమూహాన్ని ఒక్కొక్కటిగా కదిలేందుకు బదులుగా, వాటిని ఒకే సమయంలో రెండు వైపులా తరలించడానికి ప్రదర్శన సమూహాన్ని ఉపయోగిస్తాము. బహుళ ప్రదర్శిత సమూహాలను కలిగి ఉన్న డిస్ప్లే గ్రూప్ ఒకేసారి అనేక గ్రాఫిక్స్ని ఎలా మార్చవచ్చో ఇది ఒక గొప్ప ఉదాహరణ.

setupScreen (); timer.performWithDelay (1000, screenLayer); timer.performWithDelay (2000, moveOne); timer.performWithDelay (3000, moveTwo);

కోడ్ యొక్క చివరి బిట్ మేము ఈ ఫంక్షన్లను అమలు చేస్తున్నప్పుడు ఏమి జరుగుతుందో ప్రదర్శిస్తుంది. మేము టైమర్ను ఉపయోగిస్తాము.ప్రొఫెషెడ్యూల్ వేల్డెలే ఫంక్షన్ అనువర్తనం ప్రారంభించిన తర్వాత ప్రతి సెకనుకు విధులు నిర్వర్తిస్తుంది. ఈ ఫంక్షన్ మీకు తెలియకపోతే, మొదటి వేరియబుల్ మిల్లిసెకన్లలో వ్యక్తీకరించబడే ఆలస్యం మరియు రెండవది మేము ఆలస్యం తర్వాత అమలు చేయాలనుకుంటున్న ఫంక్షన్.

మీరు అనువర్తనాన్ని ప్రారంభించినప్పుడు, మీరు image1.png పైన image1.png పైన ఉండాలి. ScreenLayer ఫంక్షన్ కాల్పులు చేస్తుంది మరియు ఫ్రేమ్కు image1.png తెస్తుంది. Move1ne ఫంక్షన్ image2.png క్రింద image1.png కిందకు వచ్చును, మరియు moveTwo ఫంక్షన్ ఒకే సమయంలో రెండు చిత్రాలను కదుపుతూ చివరి కాల్పులు చేస్తుంది.

ఒక స్లో ఐప్యాడ్ పరిష్కరించడానికి ఎలా

ఈ సమూహాలలో ప్రతి ఒక్కటి వాటిలో డజన్ల కొద్దీ చిత్రాలను కలిగి ఉండటం ముఖ్యమైనది. మరియు moveTwo ఫంక్షన్ కోడ్ యొక్క ఒక లైన్ తో రెండు చిత్రాలు తరలించబడింది కేవలం, ఒక సమూహం లోపల అన్ని చిత్రాలు సమూహం ఇచ్చిన ఆదేశాలను పడుతుంది.

సాంకేతికంగా, ప్రదర్శన మా బృందం దానిలో ఉన్న ప్రదర్శన సమూహాలు మరియు చిత్రాలను కలిగి ఉండవచ్చు. అయినప్పటికీ, మంచి సమూహాన్ని సృష్టించేందుకు ఏ చిత్రాలను లేకుండా ఇతర సమూహాలకు కంటైనర్లను ప్రదర్శించడానికి వంటి కొన్ని సమూహాలను అనుమతించడానికి ఇది మంచి అభ్యాసం.

ఈ ట్యుటోరియల్ డిస్ప్లే ఆబ్జెక్ట్ను ఉపయోగించుకుంటుంది. ప్రదర్శన వస్తువు గురించి మరింత తెలుసుకోండి.

ఎలా ప్రారంభించాలో ఐప్యాడ్ అనువర్తనాలు అభివృద్ధి చెందాయి