ಐಒಎಸ್‌ನಲ್ಲಿ ಸ್ಮೂತ್ ಲೂಪಿಂಗ್ ಅನಿಮೇಷನ್ ಮಾಡಲು ಚಿತ್ರಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ಮೋಡಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ಚಲಿಸುವಂತೆ ಮಾಡುವುದು ಹೇಗೆ: ಐಒಎಸ್‌ನಲ್ಲಿ ಸರಳ ಲೂಪಿಂಗ್ ಅನಿಮೇಷನ್

ಐಒಎಸ್ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ, ಅನಿಮೇಷನ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಜೀವ ತುಂಬಬಹುದು, ಬಳಕೆದಾರರು ಇಷ್ಟಪಡುವ ಕ್ರಿಯಾತ್ಮಕ ಮತ್ತು ತೊಡಗಿಸಿಕೊಳ್ಳುವ ಅಂಶವನ್ನು ಸೇರಿಸಬಹುದು. 🌥️ ನೀವು ರಚಿಸಲು ಬಯಸಬಹುದಾದ ಒಂದು ಸಾಮಾನ್ಯ ಅನಿಮೇಷನ್ ಎಂದರೆ ಪರದೆಯ ಮೇಲೆ ಮೋಡಗಳನ್ನು ಚಲಿಸುವಂತೆ ಮೃದುವಾದ, ಲೂಪಿಂಗ್ ಪರಿಣಾಮ. ಈ ಸರಳ ಮತ್ತು ದೃಷ್ಟಿಗೆ ಇಷ್ಟವಾಗುವ ಅನಿಮೇಶನ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಆಟಗಳು, ಹವಾಮಾನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ವೈಯಕ್ತಿಕ ಯೋಜನೆಗಳಲ್ಲಿ ಶಾಂತ ವಾತಾವರಣವನ್ನು ಸೃಷ್ಟಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ನೀವು iOS ನಲ್ಲಿ ಅನಿಮೇಷನ್‌ಗೆ ಹೊಸಬರಾಗಿದ್ದರೆ, ಅದನ್ನು ತಡೆರಹಿತವಾಗಿ ಮಾಡುವುದು ಮತ್ತು ತೊಂದರೆಗಳನ್ನು ತಪ್ಪಿಸುವುದು ಹೇಗೆ ಎಂದು ನೀವು ಯೋಚಿಸುತ್ತಿರಬಹುದು.

ಅಪ್ಲಿಕೇಶನ್ ತೆರೆಯುವುದನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ತಕ್ಷಣವೇ ಮೋಡಗಳು ನಿಧಾನವಾಗಿ ಪರದೆಯ ಮೇಲೆ ಚಲಿಸುತ್ತಿರುವುದನ್ನು ನೋಡಿ, ಪರಿಪೂರ್ಣ ಪ್ರಶಾಂತ ಹಿನ್ನೆಲೆಯನ್ನು ರಚಿಸುತ್ತದೆ. ಸ್ವಿಫ್ಟ್‌ನಲ್ಲಿ `UIImageView` ಮತ್ತು `UIView` ಅನಿಮೇಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಈ ರೀತಿಯ ಪರಿಣಾಮವನ್ನು ಸಾಧಿಸಬಹುದು. ಒಂದೇ ಚಿತ್ರವನ್ನು (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಕ್ಲೌಡ್) ಅನೇಕ ಬಾರಿ ಅನಿಮೇಟ್ ಮಾಡುವುದು ಮೂಲ ಕಲ್ಪನೆಯಾಗಿದೆ, ಇದರಿಂದ ಅದು ನಿರಂತರವಾಗಿ ಚಲಿಸುತ್ತಿರುವಂತೆ ಕಂಡುಬರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಯಾವಾಗಲೂ ತೋರುತ್ತಿರುವಷ್ಟು ಸುಲಭವಲ್ಲ. ವಿಶೇಷವಾಗಿ ಪುನರಾವರ್ತಿತ ಚಿತ್ರಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಅನಿಮೇಷನ್ ಅನ್ನು ಸುಗಮಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಡೆವಲಪರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಎದುರಿಸುವ ಕೆಲವು ಮೋಸಗಳಿವೆ.

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

ಈಗ, ಆ ಮೋಡಗಳನ್ನು ಪರಿಪೂರ್ಣ ಲೂಪ್‌ನಲ್ಲಿ ಚಲಿಸುವಂತೆ ಮಾಡಲು ಪರಿಹಾರಕ್ಕೆ ಧುಮುಕೋಣ. ಎರಡು ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳು ಮತ್ತು ಸ್ವಲ್ಪ ಅನಿಮೇಷನ್ ಮ್ಯಾಜಿಕ್ ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಅಂತ್ಯವಿಲ್ಲದ, ದ್ರವ ಚಲನೆಯನ್ನು ರಚಿಸುತ್ತೀರಿ ಅದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಮೃದುವಾಗಿ ಮತ್ತು ಹೊಳಪು ಕಾಣುವಂತೆ ಮಾಡುತ್ತದೆ. ಅನಿಮೇಶನ್ ಅನ್ನು ಸರಿಪಡಿಸಲು ಮತ್ತು ಆ ಮೋಡಗಳು ಸರಿಯಾಗಿ ಚಲಿಸುವಂತೆ ಮಾಡಲು ಸಿದ್ಧರಿದ್ದೀರಾ? ಹೋಗೋಣ!

ಐಒಎಸ್‌ನಲ್ಲಿ ಕ್ಲೌಡ್ ಅನಿಮೇಷನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ಮೇಲೆ ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆಯಲ್ಲಿ, ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಅನಂತವಾಗಿ ಲೂಪ್ ಮಾಡುವ ಮೃದುವಾದ, ನಿರಂತರ ಕ್ಲೌಡ್ ಅನಿಮೇಶನ್ ಅನ್ನು ರಚಿಸುವುದು ಗುರಿಯಾಗಿದೆ. ಎರಡು ಅನಿಮೇಟ್ ಮಾಡುವುದು ಮುಖ್ಯ ಆಲೋಚನೆ UIImageView ಅದೇ ಕ್ಲೌಡ್ ಇಮೇಜ್ ಹೊಂದಿರುವ ನಿದರ್ಶನಗಳು, ಅವುಗಳನ್ನು ಪರದೆಯಾದ್ಯಂತ ಅಡ್ಡಲಾಗಿ ಚಲಿಸುತ್ತವೆ. ಫ್ರೇಮ್ ಬಳಸಿ ಅವರ ಸ್ಥಾನಗಳನ್ನು ಸರಿಹೊಂದಿಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ ಮೂಲ.x ಆಸ್ತಿ ಮತ್ತು ಈ ಸ್ಥಾನಗಳಿಗೆ ಅನಿಮೇಷನ್ ಅನ್ನು ಅನ್ವಯಿಸುವುದು. ಎರಡು ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಒಂದು ಪರದೆಯಿಂದ ಹೊರಗೆ ಚಲಿಸಿದಾಗ, ಇನ್ನೊಂದು ಅದರ ಸ್ಥಾನವನ್ನು ಪಡೆಯಲು ಸಿದ್ಧವಾಗಿದೆ, ಇದು ತಡೆರಹಿತ ಲೂಪ್ನ ಪರಿಣಾಮವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳ ಚಲನೆಯನ್ನು ಅನಿಮೇಟ್ ಮಾಡುವ ಮೂಲಕ, ಮೋಡಗಳು ನಿರಂತರವಾಗಿ ಆಕಾಶದಾದ್ಯಂತ ತೇಲುತ್ತವೆ ಎಂಬ ಭ್ರಮೆಯನ್ನು ನೀವು ನೀಡಬಹುದು. 🚀

ಕೋಡ್ನ ಮುಖ್ಯ ಅಂಶಗಳನ್ನು ವಿಭಜಿಸೋಣ. ಎರಡು ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳನ್ನು ರಚಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ, ಪ್ರತಿಯೊಂದೂ ಮೋಡಗಳ ಒಂದೇ ಚಿತ್ರವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ. ಈ ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಅಕ್ಕಪಕ್ಕದಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಎರಡನೆಯ ಚಿತ್ರ ವೀಕ್ಷಣೆಯು ಮೊದಲನೆಯದು ಕೊನೆಗೊಳ್ಳುವ ಸ್ಥಳದಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಿರಂತರ ಹಾರಿಜಾನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಮೊದಲ ಚಿತ್ರ ವೀಕ್ಷಣೆಯು ಪರದೆಯ ಅಂಚನ್ನು ತಲುಪಿದಾಗ, ಎರಡನೇ ಚಿತ್ರ ವೀಕ್ಷಣೆಯು ಸ್ವಾಧೀನಪಡಿಸಿಕೊಳ್ಳಲು ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಸೆಟಪ್ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಚಿತ್ರದ ವೀಕ್ಷಣೆಗಳ ಸ್ಥಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ ಚೌಕಟ್ಟು ಆಸ್ತಿ, ಇದು ಪೋಷಕ ವೀಕ್ಷಣೆಯೊಳಗಿನ ವೀಕ್ಷಣೆಗಳ ಗಾತ್ರ ಮತ್ತು ಸ್ಥಾನ ಎರಡನ್ನೂ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಪ್ರತಿ ಚಿತ್ರ ವೀಕ್ಷಣೆಯು ವಿಭಿನ್ನ x-ಸ್ಥಾನದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ: ಒಂದು 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಇನ್ನೊಂದು ಪರದೆಯ ಅಗಲದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಚಿತ್ರ ವೀಕ್ಷಣೆಗಳನ್ನು ಹೊಂದಿಸಿದ ನಂತರ, ಅವುಗಳನ್ನು ಅನಿಮೇಟ್ ಮಾಡುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ. ಇದನ್ನು ಇದರೊಂದಿಗೆ ಮಾಡಲಾಗುತ್ತದೆ UIView.animate ಕಾರ್ಯ, ಇದು ಕಾಲಾನಂತರದಲ್ಲಿ ವೀಕ್ಷಣೆಗಳನ್ನು ಅನಿಮೇಟ್ ಮಾಡಲು ಕಾರಣವಾಗಿದೆ. ದಿ UIView.animate ಕಾರ್ಯವು ಹಲವಾರು ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: ಅನಿಮೇಶನ್‌ನ ಅವಧಿ, ಅನಿಮೇಷನ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ಯಾವುದೇ ವಿಳಂಬ, ಅನಿಮೇಷನ್ ಆಯ್ಕೆಗಳು (ಅನಿಮೇಶನ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುವಂತಹವು) ಮತ್ತು ಅನ್ವಯಿಸಬೇಕಾದ ಅನಿಮೇಷನ್‌ಗಳ ಬ್ಲಾಕ್. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅನಿಮೇಷನ್ ಅವಧಿಯನ್ನು 20 ಸೆಕೆಂಡುಗಳಿಗೆ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು ಅನಿಮೇಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಶಾಶ್ವತವಾಗಿ ಪುನರಾವರ್ತಿಸಲು ಹೊಂದಿಸಲಾಗಿದೆ .ಪುನರಾವರ್ತನೆ ಆಯ್ಕೆಯನ್ನು. ದಿ .ಕರ್ವ್ ಲೀನಿಯರ್ ಆಯ್ಕೆಯು ಅನಿಮೇಷನ್ ಸ್ಥಿರ ವೇಗದಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಇದು ಮೃದುವಾದ, ರೇಖಾತ್ಮಕ ಚಲನೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಚಿತ್ರಗಳನ್ನು ಅವುಗಳ ಸರಿದೂಗಿಸುವ ಮೂಲಕ ಅಡ್ಡಲಾಗಿ ಸರಿಸಲಾಗುತ್ತದೆ ಮೂಲ.x ಪರದೆಯ ಅಗಲದಿಂದ.

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

import UIKit
class ViewController: UIViewController {
    var cloudsImageView1: UIImageView!
    var cloudsImageView2: UIImageView!
    let screenSize = UIScreen.main.bounds.width
    let cloudImage = UIImage(named: "cloud.png")
    override func viewDidLoad() {
        super.viewDidLoad()
        setupClouds()
        animateClouds()
    }
    func setupClouds() {
        cloudsImageView1 = UIImageView(image: cloudImage)
        cloudsImageView2 = UIImageView(image: cloudImage)
        cloudsImageView1.frame = CGRect(x: 0, y: 100, width: screenSize, height: 100)
        cloudsImageView2.frame = CGRect(x: screenSize, y: 100, width: screenSize, height: 100)
        view.addSubview(cloudsImageView1)
        view.addSubview(cloudsImageView2)
    }
    func animateClouds() {
        UIView.animate(withDuration: 20.0, delay: 0.0, options: [.repeat, .curveLinear], animations: {
            self.cloudsImageView1.frame.origin.x -= self.screenSize
            self.cloudsImageView2.frame.origin.x -= self.screenSize
        }, completion: nil)
    }
}

import UIKit
class ViewController: UIViewController {
    var cloudsImageView1: UIImageView!
    var cloudsImageView2: UIImageView!
    let screenSize = UIScreen.main.bounds.width
    let cloudImage = UIImage(named: "cloud.png")
    override func viewDidLoad() {
        super.viewDidLoad()
        setupClouds()
        animateClouds()
    }
    func setupClouds() {
        cloudsImageView1 = UIImageView(image: cloudImage)
        cloudsImageView2 = UIImageView(image: cloudImage)
        cloudsImageView1.frame = CGRect(x: 0, y: 100, width: screenSize, height: 100)
        cloudsImageView2.frame = CGRect(x: screenSize, y: 100, width: screenSize, height: 100)
        view.addSubview(cloudsImageView1)
        view.addSubview(cloudsImageView2)
    }
    func animateClouds() {
        let totalDuration = 20.0
        let animationOptions: UIView.AnimationOptions = [.repeat, .curveLinear]
        UIView.animate(withDuration: totalDuration, delay: 0.0, options: animationOptions, animations: {
            self.cloudsImageView1.frame.origin.x -= self.screenSize
            self.cloudsImageView2.frame.origin.x -= self.screenSize
        }) { [weak self] _ in
            self?.recycleClouds()
        }
    }
    func recycleClouds() {
        if cloudsImageView1.frame.origin.x <= -screenSize {
            cloudsImageView1.frame.origin.x = screenSize
        }
        if cloudsImageView2.frame.origin.x <= -screenSize {
            cloudsImageView2.frame.origin.x = screenSize
        }
    }
}

import UIKit
class ViewController: UIViewController {
    var cloudsImageView1: UIImageView!
    var cloudsImageView2: UIImageView!
    let screenSize = UIScreen.main.bounds.width
    let cloudImage = UIImage(named: "cloud.png")
    var totalDuration = 20.0
    override func viewDidLoad() {
        super.viewDidLoad()
        setupClouds()
        animateClouds()
    }
    func setupClouds() {
        cloudsImageView1 = UIImageView(image: cloudImage)
        cloudsImageView2 = UIImageView(image: cloudImage)
        cloudsImageView1.frame = CGRect(x: 0, y: 100, width: screenSize, height: 100)
        cloudsImageView2.frame = CGRect(x: screenSize, y: 100, width: screenSize, height: 100)
        view.addSubview(cloudsImageView1)
        view.addSubview(cloudsImageView2)
    }
    func animateClouds() {
        UIView.animate(withDuration: totalDuration, delay: 0.0, options: [.repeat, .curveLinear], animations: {
            self.cloudsImageView1.frame.origin.x -= self.screenSize
            self.cloudsImageView2.frame.origin.x -= self.screenSize
        }, completion: { [weak self] _ in
            self?.optimizeMemory()
        })
    }
    func optimizeMemory() {
        if cloudsImageView1.frame.origin.x <= -screenSize {
            cloudsImageView1.frame.origin.x = screenSize
        }
        if cloudsImageView2.frame.origin.x <= -screenSize {
            cloudsImageView2.frame.origin.x = screenSize
        }
    }
}

ಐಒಎಸ್‌ನಲ್ಲಿ ತಡೆರಹಿತ ಮೇಘ ಅನಿಮೇಷನ್ ರಚಿಸಲಾಗುತ್ತಿದೆ

iOS ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಕ್ಲೌಡ್ ಡ್ರಿಫ್ಟ್‌ನಂತಹ ಲೂಪಿಂಗ್ ಚಿತ್ರವನ್ನು ಅನಿಮೇಟ್ ಮಾಡಲು, ದೃಶ್ಯ ಪರಿಣಾಮಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಎರಡನ್ನೂ ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸುವ ಅಗತ್ಯವಿದೆ. ನೀವು ಪರದೆಯಾದ್ಯಂತ ಚಲಿಸುವ ಮೋಡಗಳ ಅಂತ್ಯವಿಲ್ಲದ ಲೂಪ್ ಅನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಾಗ, ಪರಿಹರಿಸಲು ಕೆಲವು ಪ್ರಮುಖ ಅಂಶಗಳಿವೆ: ಸಮಯ, ನಿರ್ದೇಶನ ಮತ್ತು ವೀಕ್ಷಣೆಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಅನಿಮೇಶನ್ ಅನ್ನು ಸುಗಮಗೊಳಿಸುವ ಪ್ರಮುಖ ಅಂಶವೆಂದರೆ ಚಿತ್ರದ ವೀಕ್ಷಣೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸುವುದು ಆದ್ದರಿಂದ ಅವುಗಳು ಕಣ್ಮರೆಯಾಗುವುದಿಲ್ಲ ಅಥವಾ ಸಿಲುಕಿಕೊಳ್ಳುವುದಿಲ್ಲ. ಎರಡನ್ನು ಬಳಸುವುದು UIImageView ಅನಿಮೇಶನ್‌ನ ನಿದರ್ಶನಗಳು ಮೋಡಗಳು ನಿರಂತರವಾಗಿ ಚಲಿಸುತ್ತಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಒಂದು ಚಿತ್ರವು ಆಫ್-ಸ್ಕ್ರೀನ್‌ನಿಂದ ಚಲಿಸುವಾಗ ಮತ್ತು ಇನ್ನೊಂದು ಅದರ ಸ್ಥಾನವನ್ನು ಪಡೆದುಕೊಂಡರೂ ಸಹ. ಚಿತ್ರಗಳು ಪರದೆಯ ಅಂಚಿನಿಂದ ಹಿಂದೆ ಸರಿದ ನಂತರ ಅವುಗಳನ್ನು ಮರುಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಈ ಮರುಹೊಂದಿಸದೆಯೇ, ಅನಿಮೇಷನ್ ಮುರಿಯಬಹುದು, ಇದರಿಂದಾಗಿ ಮೋಡಗಳು ಕಣ್ಮರೆಯಾಗಬಹುದು ಅಥವಾ ಲೂಪ್‌ನಲ್ಲಿ ಅಂತರವನ್ನು ಬಿಡಬಹುದು.

ಅನಿಮೇಷನ್‌ನ ಮತ್ತೊಂದು ನಿರ್ಣಾಯಕ ಅಂಶವು ಒಳಗೊಂಡಿರುತ್ತದೆ frame.origin.x ಆಸ್ತಿ, ಇದು ಕ್ಲೌಡ್ ಚಿತ್ರಗಳ ಸ್ಥಾನವನ್ನು ನಿಯಂತ್ರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ವಿಭಿನ್ನ ಆರಂಭಿಕ ಹಂತಗಳಲ್ಲಿ ಚಿತ್ರಗಳ ಸಮತಲ ಸ್ಥಾನವನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ, ನೀವು ಅನಂತ ಚಲನೆಯ ಭ್ರಮೆಯನ್ನು ರಚಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಒಂದು ಚಿತ್ರವು ಆಫ್-ಸ್ಕ್ರೀನ್‌ನಿಂದ ಚಲಿಸಿದಾಗ ಮತ್ತು ಸರಿಯಾದ ಸ್ಥಾನಕ್ಕೆ ಮರುಹೊಂದಿಸದಿದ್ದಾಗ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆ ಉಂಟಾಗುತ್ತದೆ. ಚಿತ್ರವು ಪರದೆಯ ಅಂಚಿನಿಂದ ಹಿಂದೆ ಸರಿಯುವುದನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ಸರಿಯಾದ ವಿಧಾನವಾಗಿದೆ, ನಂತರ ಅದನ್ನು ಇನ್ನೊಂದು ಬದಿಯಲ್ಲಿ ಮತ್ತೆ ಪ್ರಾರಂಭಿಸಲು ಮರುಸ್ಥಾಪಿಸಿ. ಅನಿಮೇಷನ್ ಬ್ಲಾಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಿರಂತರ ಹರಿವನ್ನು ಖಾತ್ರಿಪಡಿಸುವ ಪುನರಾವರ್ತಿತ ಮತ್ತು ನಿರಂತರ ಅನಿಮೇಷನ್ ಅನ್ನು ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಚಲನೆಯು ಸುಗಮವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಬಳಸಿ UIView.animate ಮುಂತಾದ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ವಿಧಾನ .ಪುನರಾವರ್ತನೆ ಲೂಪಿಂಗ್ ಮತ್ತು .ಕರ್ವ್ ಲೀನಿಯರ್ ಸಮ ವೇಗಕ್ಕಾಗಿ.

ಅಂತಿಮವಾಗಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಮೃದುತ್ವಕ್ಕಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು ದೃಶ್ಯ ಪರಿಣಾಮವನ್ನು ಸಾಧಿಸುವಷ್ಟೇ ಮುಖ್ಯವಾಗಿದೆ. ನೀವು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಬೇಕು ಮತ್ತು ಅನಿಮೇಷನ್ ಸಮಯದಲ್ಲಿ ಅನಗತ್ಯ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ತಪ್ಪಿಸಬೇಕು. ಬಳಸುತ್ತಿದೆ weak self ಮುಚ್ಚುವಿಕೆ-ಆಧಾರಿತ ಅನಿಮೇಷನ್‌ಗಳಲ್ಲಿನ ಉಲ್ಲೇಖಗಳು ಉಳಿಸಿಕೊಳ್ಳುವ ಚಕ್ರಗಳನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅನಿಮೇಷನ್ ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ ಅಥವಾ ನಿಮಗೆ ಹೆಚ್ಚು ಸುಧಾರಿತ ತಂತ್ರಗಳ ಅಗತ್ಯವಿದ್ದರೆ, ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ CADisplayLink ನೈಜ-ಸಮಯದ ಫ್ರೇಮ್ ನವೀಕರಣಗಳಿಗಾಗಿ, ಇದು ಅನಿಮೇಶನ್‌ನ ಸಮಯ ಮತ್ತು ಮೃದುತ್ವದ ಮೇಲೆ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ. ವಿಭಿನ್ನ ಪರದೆಯ ಗಾತ್ರಗಳು ಮತ್ತು ದೃಷ್ಟಿಕೋನಗಳಲ್ಲಿ ಅನಿಮೇಷನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಸಹ ನಿರ್ಣಾಯಕವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಎಲ್ಲಾ ಸಾಧನಗಳಲ್ಲಿ ನಿರೀಕ್ಷಿಸಿದಂತೆ ಅನಿಮೇಷನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. 📱