ಲೇಯರ್, ಮೂವಿಂಗ್ ಮತ್ತು ಗ್ರಾಫಿಕ್ಸ್ ಟು ಫ್ರಂಟ್ ಅನ್ನು ಹೇಗೆ ಪಡೆಯುವುದು

ಗ್ರಾಫಿಕ್ಸ್ ಕುಶಲತೆಯಿಂದ ಕರೋನಾ 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 ಲೈಬ್ರರಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರದರ್ಶನ ಗುಂಪುಗಳ ಮೂಲಕ ಘೋಷಿಸುತ್ತದೆ: ಪ್ರದರ್ಶನ ಮುಖ್ಯ, ಪ್ರದರ್ಶನ ಮೊದಲ ಮತ್ತು ಪ್ರದರ್ಶನ ಎರಡನೆಯದು. ನಾವು ಇದನ್ನು ನಮ್ಮ ಗ್ರಾಫಿಕ್ಸ್ನ ಮೊದಲ ಪದರಕ್ಕೆ ಬಳಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಸರಿಸುತ್ತೇವೆ. Global_move_x ವೇರಿಯೇಬಲ್ ಪ್ರದರ್ಶನದ ಅಗಲದ 20% ಗೆ ಹೊಂದಿಸಲಾಗಿದೆ ಆದ್ದರಿಂದ ನಾವು ಚಲನೆಯನ್ನು ನೋಡಬಹುದು.

ಕಾರ್ಯ ಸೆಟಪ್ ಸ್ಕ್ರೀನ್ () ಪ್ರದರ್ಶನ ಮುಖ್ಯ: ಸೇರಿಸು (ಪ್ರದರ್ಶನ ಮೊದಲ); ಪ್ರದರ್ಶನ ಮುಖ್ಯ: ಸೇರಿಸು (ಪ್ರದರ್ಶನ ಎರಡನೆಯದು); ಪ್ರದರ್ಶನ ಮೊದಲ: toFront (); ಪ್ರದರ್ಶನ ಎರಡನೆಯದು: toFront (); ಸ್ಥಳೀಯ ಹಿನ್ನೆಲೆ = display.newImage ("image1.png", 0,0); ಪ್ರದರ್ಶಕ ಮೊದಲ: ಸೇರಿಸು (ಹಿನ್ನೆಲೆ); ಸ್ಥಳೀಯ ಹಿನ್ನೆಲೆ = display.newImage ("image2.png", 0,0); ಪ್ರದರ್ಶನ ಎರಡನೇಯ: ಸೇರಿಸು (ಹಿನ್ನೆಲೆ); ಅಂತ್ಯ

ಮುಖ್ಯ ಪ್ರದರ್ಶನ ಗುಂಪಿಗೆ ಪ್ರದರ್ಶನ ಗುಂಪುಗಳನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು ಎನ್ನುವುದನ್ನು setupScreen ಕಾರ್ಯವು ತೋರಿಸುತ್ತದೆ. ನಾವು ವಿಭಿನ್ನ ಗ್ರಾಫಿಕ್ ಲೇಯರ್ಗಳನ್ನು ಹೊಂದಿಸಲು toFront () ಕಾರ್ಯವನ್ನು ಸಹ ಬಳಸುತ್ತೇವೆ, ಕೊನೆಯದಾಗಿ ಘೋಷಿಸಿದ ಎಲ್ಲಾ ಸಮಯದ ಮೇಲೆ ನಾವು ಬಯಸುವ ಪದರವನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪ್ರದರ್ಶನವನ್ನು ಸರಿಸುಮಾರಾಗಿ ಮುಂಭಾಗಕ್ಕೆ ಮುಂದಕ್ಕೆ ತರಲು ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಇದು ಪ್ರದರ್ಶನ ಸೆಕೆಂಡ್ ಗುಂಪಿನ ಕೆಳಗೆ ಇರುವಂತೆ ಡೀಫಾಲ್ಟ್ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಪ್ರತಿ ಪ್ರದರ್ಶಕ ಗುಂಪನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಲೇಯರಿಂಗ್ ಮಾಡುವ ಅಭ್ಯಾಸವನ್ನು ಪಡೆಯುವುದು ಒಳ್ಳೆಯದು. ಹೆಚ್ಚಿನ ಯೋಜನೆಗಳು ಎರಡು ಪದರಗಳಿಗಿಂತ ಹೆಚ್ಚು ಕೊನೆಗೊಳ್ಳುತ್ತವೆ.

ನಾವು ಪ್ರತಿ ಗುಂಪಿಗೂ ಕೂಡ ಚಿತ್ರವನ್ನು ಸೇರಿಸಿದ್ದೇವೆ. ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರಾರಂಭಿಸಿದಾಗ, ಎರಡನೇ ಚಿತ್ರವು ಮೊದಲ ಚಿತ್ರದ ಮೇಲೆ ಇರಬೇಕು.

ಫಂಕ್ಷನ್ ಸ್ಕ್ರೀನ್ ಲೇಯರ್ () ಪ್ರದರ್ಶನ ಮೊದಲ: toFront (); ಅಂತ್ಯ

ನಾವು ಈಗಾಗಲೇ ನಮ್ಮ ಗ್ರಾಫಿಕ್ಸ್ ಅನ್ನು ಡಿಸ್ಪ್ಲೇಸ್ಫಾರ್ಸ್ಟ್ ಗುಂಪಿನ ಮೇಲಿರುವ ಪ್ರದರ್ಶನ ಸೆಕೆಂಡ್ ಗುಂಪಿನೊಂದಿಗೆ ಲೇಯರ್ಡ್ ಮಾಡಿದ್ದೇವೆ. ಈ ಕಾರ್ಯವು ಮುಂಭಾಗಕ್ಕೆ ಮೊದಲ ಬಾರಿಗೆ ಚಲಿಸುತ್ತದೆ.

ಕಾರ್ಯ moveOne () displaySecond.x = displaySecond.x + global_move_x; ಅಂತ್ಯ

ನಡೆಸುವಿಕೆಯ ಕಾರ್ಯವು ಪರದೆಯ ಅಗಲದ 20% ನಷ್ಟು ಬಲಕ್ಕೆ ಎರಡನೇ ಚಿತ್ರವನ್ನು ಸರಿಸುತ್ತದೆ. ನಾವು ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯುವಾಗ, ಪ್ರದರ್ಶನ ಸೆಕೆಂಡು ಗುಂಪು ಪ್ರದರ್ಶನದ ಮೊದಲ ಗುಂಪಿನ ಹಿಂದೆ ಇರುತ್ತದೆ.

ಫಂಕ್ಷನ್ ಮೂವ್ಟ್ಟ್ವಾ () ಪ್ರದರ್ಶನMain.x = displayMain.x + global_move_x; ಅಂತ್ಯ

ಈ ಕ್ರಿಯೆಯು ಪರದೆಯ ಅಗಲದ 20% ನಷ್ಟು ಚಿತ್ರಗಳನ್ನು ಎರಡೂ ಚಿತ್ರಗಳನ್ನು ಬಲಕ್ಕೆ ಸರಿಸುತ್ತದೆ. ಹೇಗಾದರೂ, ಪ್ರತಿ ಗುಂಪನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಚಲಿಸುವ ಬದಲು, ನಾವು ಪ್ರದರ್ಶಕ ಮುಖ್ಯ ಗುಂಪನ್ನು ಅದೇ ಸಮಯದಲ್ಲಿ ಅವುಗಳನ್ನು ಸರಿಸಲು ಬಳಸುತ್ತೇವೆ. ಅನೇಕ ಪ್ರದರ್ಶನ ಗುಂಪುಗಳನ್ನು ಹೊಂದಿರುವ ಪ್ರದರ್ಶನ ಗುಂಪನ್ನು ಅನೇಕ ಗ್ರಾಫಿಕ್ಸ್ ಅನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕುಶಲತೆಯಿಂದ ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಒಂದು ಉತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ.

setupScreen (); timer.performWithDelay (1000, ಸ್ಕ್ರೀನ್ ಲೇಯರ್); timer.performWithDelay (2000, moveOne); timer.performWithDelay (3000, moveTwo);

ನಾವು ಈ ಕಾರ್ಯಗಳನ್ನು ನಡೆಸಿದಾಗ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಈ ಕೊನೆಯ ಬಿಟ್ ಕೋಡ್ ತೋರಿಸುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ ನಾವು ಪ್ರತಿ ಸೆಕೆಂಡಿನಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಆಫ್ ಮಾಡಲು ಟೈಮರ್.ಪೆರ್ಫಾರ್ಮ್ ವಿಥ್ಡೆಲೇ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ನೀವು ಈ ಕ್ರಿಯೆಯೊಂದಿಗೆ ಪರಿಚಯವಿಲ್ಲದಿದ್ದರೆ, ಮೊದಲ ವೇರಿಯೇಬಲ್ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸುವ ವಿಳಂಬ ಸಮಯ ಮತ್ತು ಎರಡನೆಯದು ಆ ವಿಳಂಬದ ನಂತರ ಚಲಾಯಿಸಲು ನಾವು ಬಯಸುವ ಕಾರ್ಯವಾಗಿದೆ.

ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ನೀವು ಇಮೇಜ್ 2.png ಮೇಲೆ ಇಮೇಜ್ 2.png ಅನ್ನು ಹೊಂದಿರಬೇಕು. ಪರದೆಯ ಲೇಸರ್ ಕಾರ್ಯವು ಮುಂಭಾಗಕ್ಕೆ ಇಮೇಜ್1.png ಅನ್ನು ಬೆಂಕಿಯನ್ನು ತರುತ್ತದೆ ಮತ್ತು ತರಲಿದೆ. MoveOne ಕ್ರಿಯೆಯು image2.png ನಿಂದ ಇಮೇಜ್2.png ಅನ್ನು ಸರಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಕ್ರಿಯೆಯು ಕೊನೆಯ ಬಾರಿಗೆ ಬೆಂಕಿಯಿರುತ್ತದೆ ಮತ್ತು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಎರಡೂ ಚಿತ್ರಗಳನ್ನು ಚಲಿಸುತ್ತದೆ.

ನಿಧಾನ ಐಪ್ಯಾಡ್ ಅನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸುವುದು

ಈ ಪ್ರತಿಯೊಂದು ಗುಂಪುಗಳು ಅವುಗಳಲ್ಲಿ ಡಜನ್ಗಟ್ಟಲೆ ಚಿತ್ರಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಎಂದು ನೆನಪಿಡುವ ಮುಖ್ಯವಾಗಿದೆ. ಮತ್ತು ಚಳುವಳಿಯು ಒಂದೇ ಕೋಡ್ನೊಂದಿಗೆ ಎರಡೂ ಇಮೇಜ್ಗಳನ್ನು ಚಲಿಸಿದಂತೆಯೇ, ಗುಂಪಿನೊಳಗಿನ ಎಲ್ಲಾ ಇಮೇಜ್ಗಳು ಸಮೂಹಕ್ಕೆ ನೀಡಿದ ಆಜ್ಞೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ತಾಂತ್ರಿಕವಾಗಿ, ಪ್ರದರ್ಶಕ ತಂಡವು ಅದರಲ್ಲಿರುವ ಪ್ರದರ್ಶನ ಗುಂಪುಗಳು ಮತ್ತು ಚಿತ್ರಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಉತ್ತಮ ಸಂಘಟನೆಯನ್ನು ರಚಿಸುವ ಸಲುವಾಗಿ ಯಾವುದೇ ಗುಂಪುಗಳಿಲ್ಲದೆಯೇ ಪ್ರದರ್ಶನ ಗುಂಪು ಕಾರ್ಯವನ್ನು ಇತರ ಗುಂಪುಗಳಿಗೆ ಧಾರಕಗಳಾಗಿ ಕೆಲವು ಗುಂಪುಗಳಿಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ಪ್ರದರ್ಶನ ವಸ್ತುವನ್ನು ಬಳಸುತ್ತದೆ. ಪ್ರದರ್ಶನ ವಸ್ತುವಿನ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ.

IPad ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ಹೇಗೆ ಪ್ರಾರಂಭಿಸುವುದು