| समस्या:
इस ट्यूटोरियल के पीछे की अवधारणा एक ऑनलाइन चर्चा के बाहर आ गया. एक आदमी After Effects सरगर्म उस समय और अंतरिक्ष में बेतरतीब था गति उत्पन्न करने के लिए एक अभिव्यक्ति के साथ आने की कोशिश कर रहा था. यह है, लक्षित स्थान के रूप में यादृच्छिक होगी होगा वहाँ पाने के लिए लगता है समय. समस्या यह है कि जब आप एक ऐसी अभिव्यक्ति का विकास करने की कोशिश कर रही मुठभेड़ कि वहाँ सिर्फ एक फ्रेम से करने के लिए समय में चर आगे की कीमत ले जाने के लिए एक अच्छा तरीका नहीं लगती है कि अगले. किसी भी चर है कि आप को परिभाषित अगले सीमा में चला गया होगा. अस्पष्टता के लिए निम्नलिखित उदाहरण अभिव्यक्ति पर विचार:
अगर (समय = 0) (
एक्स = 10
}
और (
एक्स = एक्स + 1
}
यह पहली फ्रेम में ठीक काम करता है. क्योंकि एक्स अपरिभाषित है दूसरे पर आपको कोई त्रुटि मिलती है फ्रेम. अभिव्यक्ति कि एक्स 10 पिछले फ्रेम पर था याद नहीं है. यह एक गंभीर सीमा के कारण एक बार तुम यह कैसे करना चाहिए लंबा फैसला जब तुम समय की एक यादृच्छिक राशि पर कुछ करने की कोशिश कर रहे हैं हो जाती है, आप हर फ्रेम में जाँच करने के लिए अगर आप अभी तक कर रहे हैं देखने के लिए की ज़रूरत है. करना मुश्किल अगर तुम एक फ्रेम से कि मूल्य पारित नहीं कर सकती अगले.
बचाव करने के लिए seed_random:
यह है कि आप (के लिए बढ़ाया के साथ इस समस्या के आसपास मिल सकती है निकली AE 5.5) seed_random समारोह. इस समारोह में आप यादृच्छिक संख्या की एक repeatable तारतम्य स्थापित करने के लिए और उन्हें पुनर्जन्म की अनुमति देता है करेगा, बस एक पिछले मूल्य का बीज बहाल करके और फिर यादृच्छिक () समारोह बुला. क्योंकि यद्यपि हम एक सीमा से हमारे यादृच्छिक मूल्यों पास नहीं कर सकते हमें इस समस्या का समाधान देता है अगले, हम seed_random का प्रयोग कर उन्हें विश्राम कर सकते हैं. कैसे seed_random देखो चलो काम करता है.
और फिर "बुनियादी COMP खुले" इस परियोजना फ़ाइल खोलने. यह एक 50x50 ठोस परत के साथ सिर्फ एक 640x480 COMP जोड़ा है. "1 ठोस" चुनें और स्थिति संपत्ति उजागर. Alt-क्लिक (विकल्प क्लिक करें) करने के लिए इस संपत्ति के लिए अभिव्यक्ति को सक्रिय करने के स्टॉपवॉच पर. निम्नलिखित अभिव्यक्ति दर्ज:
[यादृच्छिक (0,This_comp.चौड़ाई),यादृच्छिक (0,This_comp.ऊंचाई)];
यह इस COMP में एक यादृच्छिक स्थान पर कूदने के वर्ग पैदा होगा. पूर्वावलोकन के COMP. तुम नोटिस हूँ कि हर फ्रेम पर एक नए स्थान के लिए वर्ग कूदता. बहुत उपयोगी नहीं. अभिव्यक्ति के लिए तो एक नई लाइन जोड़ने कि यह अब पढ़ता:
Seed_random (1,सच);
[यादृच्छिक (0,This_comp.चौड़ाई),यादृच्छिक (0,This_comp.ऊंचाई)];
सूचना है कि एक यादृच्छिक स्थिति को फिर से इस वर्ग कूदता है, लेकिन यह रहती है जब आप पूर्वावलोकन वहाँ. इस नए व्यवहार परिवर्तन की वजह से है कि Adobe इस seed_random कार्य करने के लिए बनाया AE 5.5. वे एक दूसरे पैरामीटर जोड़ दिया है, कि जब "को सच" इतनी यादृच्छिक समारोह सेट सेट कि यादृच्छिक संख्या समय पर निर्भर नहीं करते उत्पन्न. इस यादृच्छिक संख्या की परत संख्या पर निर्भर करते हैं, संपत्ति संख्या, इस seed_random कॉल (the "बीज") में पहली पैरामीटर के मूल्य, और यादृच्छिक समारोह में बुलाया गया है बार की संख्या. जो कि एक ही अभिव्यक्ति एक अलग परत या जायदाद में (जो बाद में हम इस से जल्दी हमारी COMP जटिलता को जोड़ने के लिए) लाभ ले जाएगा अलग यादृच्छिक संख्या उत्पन्न होगा मतलब. इस "बीज" कुछ दूसरे नंबर करने के लिए पैरामीटर बदलने की कोशिश. तुम नोटिस हूँ कि एक अलग स्थान पर वर्ग चलता रहता है और वहाँ. "करने के लिए दूसरा पैरामीटर बदल झूठी" और सूचना है कि जब आप पूर्वावलोकन, इस वर्ग के सभी स्थानों पर फिर से कूदता है.
अपनी अभिव्यक्ति के लिए बहुत थोड़ा और कोड जोड़ने कि यह इस तरह दिखता है:
(समय 1) अगर (
Seed_random (1,सच)
}
और (
Seed_random (2,सच)
}
[यादृच्छिक (0,This_comp.चौड़ाई),यादृच्छिक (0,This_comp.ऊंचाई)];
अब तुम नोटिस हूँ कि जब आप पूर्वावलोकन, के लिए एक स्थान पर वर्ग रहता पहली और दूसरी तो COMP के शेष के लिए किसी अन्य स्थान के लिए कूदता है.
तो हम कैसे इस्तेमाल कर इस नये, अधिक शक्तिशाली seed_random समारोह? यहाँ चाबी अवधारणा है: दूसरा पैरामीटर "सच" के सेट के साथ, एक दिया परत के लिए, संपत्ति, और बीज मूल्य, जब आप पर ही निर्भर करता है कि यादृच्छिक () समारोह में बोल पाने के यादृच्छिक संख्या आप कैसे बीज स्थापना के बाद से इस समारोह को बुलाया है कई बार. यह है, पहली बार तुम यादृच्छिक () आप एक particlar यादृच्छिक संख्या मिलेगा बीज स्थापित करने के बाद फोन (का फोन इसे एक्स) करते हैं. दूसरे फोन (है यह एक y कॉल) और इतने पर हैं एक दूसरे यादृच्छिक संख्या उत्पन्न करेगा. लेकिन अगर आप seed_random फिर से मूल बीज के साथ फोन, इस अनुक्रम में शुरू होगा. यह है, इस यादृच्छिक अगले () कॉल (एक्स इस मामले में) मूल यादृच्छिक संख्या पुनर्जन्म होगा. एक पूरी तरह से अलग अनुक्रम कारण होगा एक अलग मूल्य बीज का उपयोग करते हुए उत्पन्न होना. विचार का उदाहरण निम्नलिखित:
Seed_random (1,सच); / / बीज मूल्य निर्धारित
एक = यादृच्छिक ();
ख = यादृच्छिक ();
ग = यादृच्छिक ();
Seed_random (1,सच); / उसी मूल्य का बीज रीसेट /
मैं = यादृच्छिक ();
जम्मू = यादृच्छिक ();
K = यादृच्छिक ();
Seed_random (2,सच) / / नई बीज
Q = यादृच्छिक ();
R = यादृच्छिक ();
S = यादृच्छिक ();
Seed_random (1,सच); / / मूल बीज reestablish
एक्स = यादृच्छिक ();
Y = यादृच्छिक ();
Z = यादृच्छिक ();
इस मामले में, A,B, और ग सभी यादृच्छिक अलग होगा संख्या. फिर भी, एक और मैं एक ही हो जाएगा, ख और जे एक ही हो जाएगा, और ग और कश्मीर के एक ही हो जाएगा, क्योंकि बीज इस मामले में की गई रीसेट 1 (है) और यादृच्छिक अनुक्रम में शुरू. Q,र और क्योंकि बीज 2 में बदल दिया गया है ओं यादृच्छिक संख्या की एक नई अनुक्रम होगा. इस अनुक्रम एक्स,Y,जेड ने एक के रूप में ही की जाएगी,B,ग और मैं,J,कश्मीर क्योंकि बीज 1 करने के लिए फिर से स्थापित किया गया है. इसलिए हम यादृच्छिक संख्या के एक दृश्य के लिए कि उन लोगों की संख्या उत्पन्न बीज मूल्य reestablishing तक वापस आ सकते हैं.
यह कैसे हमारी मदद करता है? हमारे यादृच्छिक गति उत्पन्न करने के लिए, हम प्रस्ताव के वर्तमान खंड के बारे में कई बातें जानने की जरूरत किसी भी फ्रेम में: प्रारंभ समय, आरंभ स्थान, अंत समय, और अंत स्थिति. इन सभी यादृच्छिक संख्या कि हम गति के प्रत्येक खंड के लिए एक अलग मूल्य बीज का उपयोग करते हुए उत्पन्न करेगा हो जाएगा. और हम बीज मान आधार होगा हम वर्तमान में हैं, जो खंड पर. इतना सब हमें करना है बाहर उस में है, जो क्षेत्र (जिसमें से बीज मूल्य की कल्पना करने में सक्षम होंगे कि अभिव्यक्ति की कल्पना करने में सक्षम होना है) है, बीज सेट, और कहा कि हमें समय शुरू देना यादृच्छिक संख्या के अनुक्रम पुनर्जन्म, आरंभ स्थान, अंत समय, और इस खंड के लिए अंत स्थिति मूल्यों.
ठीक है - हमारा लक्ष्य इस अभिव्यक्ति के लिए क्या होगा की समीक्षा करते हैं. हम आसानी से एक और करने के लिए स्क्रीन पर एक यादृच्छिक स्थान से स्थानांतरित करने के लिए वर्ग चाहता हूँ. हम भी अनियमित होने का (के बीच कहते हैं यह यह करने के लिए लगता है समय चाहिए .5 और 2 सेकंड). इस अभिव्यक्ति करता हूँ कि:
Seg_start_time = 0; / / आरंभिक स्थिति
Seg_अंत_time = 0;
मैं = 1;
Tmin = .5; / / न्यूनतम चक्र समय (नहीं किया जा सकता है शून्य)
Tmax = 2; / / अधिकतम समय चक्र
(समय जबकि = seg_अंत_time) (
मैं मैं = 1; seed_random (मैं,सच);
Seg_start_time = seg_अंत_time;
Seg_अंत_time = seg_अंत_time + (tmin यादृच्छिक,Tmax);
}
प्रतिशत = (बार - seg_start_time) / (seg_अंत_time - seg_start_time);
Target_x = यादृच्छिक () * This_comp.चौड़ाई;
Target_y = यादृच्छिक () * This_comp.ऊंचाई;
Seed_random (मैं-1,सच);
एक्स = यादृच्छिक (); / / यह एक फेंक-दूर मूल्य है
Old_x = यादृच्छिक () * This_comp.चौड़ाई;
Old_y = यादृच्छिक () * This_comp.ऊंचाई;
(प्रतिशत कम,[old_x,Old_y],[target_x,Target_y]);
इस अभिव्यक्ति कॉपी और स्थिति अभिव्यक्ति में पेस्ट (या बस "बुनियादी COMP खुला + अभिव्यक्ति"). पूर्वावलोकन के COMP. क्या आपको लगता है कि वर्ग अब एक अच्छा है नोटिस हूँ, द्रव, उस अवधि और दिशा में यादृच्छिक है प्रस्ताव.
इस अभिव्यक्ति में, "मैं" हमारे खंड काउंटर है, हम यह भी कहा कि क्षेत्र के लिए बीज मूल्य के रूप में जो प्रयोग करेंगे. "tmin" और "tmax" प्रत्येक खंड की अवधि के लिए यादृच्छिक बार संभव की श्रेणी को परिभाषित. इस मामले में, एक खंड के बीच पिछले जाएगा .5 और 2 सेकंड. इस "जबकि" पाश है जहां अभिव्यक्ति आंकड़े बाहर इसे में है, जो खंड. यह पहुँच है बीज incrementing और एक मूल्य को वर्तमान समय की तुलना में अधिक से अधिक तक यादृच्छिक खंड durations accumulating द्वारा इस करता है. यह शुरू जानता है इस बिंदु पर, अंत, मौजूदा खंड की और मौजूदा समय तो यह है कि पूरा हो गया है इस क्षेत्र के प्रतिशत की गणना कर सकते हैं. यह यादृच्छिक () के लक्ष्य को प्राप्त करने के लिए एक्स और दो बार और समारोह y इस खंड के अंत की स्थिति के लिए निर्देशांक कॉल. अगले भाग थोड़ा मुश्किल है. अभिव्यक्ति अभी भी इस क्षेत्र की शुरुआत की स्थिति की गणना कर सकते हैं ताकि यह पता करने के लिए (के प्रतिशत के आधार पर पूरा) वर्तमान स्थिति की आवश्यकता है. के बाद से शुरू की स्थिति के पिछले भाग के अंत की स्थिति के रूप में ही है, हम सिर्फ पिछले खंड के बीज पर वापस जाने के लिए बीज घटाव. अभिव्यक्ति तो यादृच्छिक () एक्स और अंत के लिए y पिछले खंड के निर्देशांक समारोह कॉल. आपको लगता है कि वहाँ एक "फेंक है दूर" कॉल करने के लिए नोटिस देंगे यादृच्छिक () से पहले एक्स और y मानों पिछले निर्धारित कर रहे हैं. यह प्रत्येक बीज के कारण के लिए है, पहली यादृच्छिक () फोन हमेशा अंत समय के लिए (हम पहले से ही) जो पता है - 2 और 3. कॉल एक्स के लिए उपयोग किया जाता है और Y निर्देशांक प्रयोग किया जाता है.
"को" अभिव्यक्ति COMP खुला. इस COMP की अस्पष्टता और रोटेशन के लिए समान randomizing भाव के अलावा के अलावा पिछले COMP के रूप में ही है. इस अस्पष्टता अभिव्यक्ति है:
Seg_start_time = 0; / / आरंभिक स्थिति
Seg_अंत_time = 0;
मैं = 1;
Tmin = .5; / / न्यूनतम चक्र समय (नहीं किया जा सकता है शून्य)
Tmax = 2; / / अधिकतम समय चक्र
(समय जबकि = seg_अंत_time) (
मैं मैं = 1; seed_random (मैं,सच);
Seg_start_time = seg_अंत_time;
Seg_अंत_time = seg_अंत_time + (tmin यादृच्छिक,Tmax);
}
प्रतिशत = (बार - seg_start_time) / (seg_अंत_time - seg_start_time);
Target_मत पारदर्श = यादृच्छिक () * 100;
Seed_random (मैं-1,सच);
एक्स = यादृच्छिक (); / / यह एक फेंक-दूर मूल्य है
Old_मत पारदर्श = यादृच्छिक () * 100;
(प्रतिशत कम,Old_मत पारदर्श,Target_मत पारदर्श);
और रोटेशन अभिव्यक्ति है:
Seg_start_time = 0; / / आरंभिक स्थिति
Seg_अंत_time = 0;
मैं = 1;
Tmin = .5; / / न्यूनतम चक्र समय (नहीं किया जा सकता है शून्य)
Tmax = 2; / / अधिकतम समय चक्र
(समय जबकि = seg_अंत_time) (
मैं मैं = 1; seed_random (मैं,सच);
Seg_start_time = seg_अंत_time;
Seg_अंत_time = seg_अंत_time + (tmin यादृच्छिक,Tmax);
}
प्रतिशत = (बार - seg_start_time) / (seg_अंत_time - seg_start_time);
Target_rotation = यादृच्छिक () * 360;
Seed_random (मैं-1,सच);
एक्स = यादृच्छिक (); / / यह एक फेंक-दूर मूल्य है
Old_rotation = यादृच्छिक () * 360;
(प्रतिशत कम,Old_rotation,Target_rotation);
इन अभिव्यक्ति के लगभग है कि वे मान अस्पष्टता और रोटेशन के लिए उपयुक्त की एक श्रृंखला उत्पन्न करने के लिए संशोधित किया गया है छोड़कर स्थिति के लिए एक के समान हैं. पूर्वावलोकन के COMP और सूचना है कि वर्ग अब यादृच्छिक रोटेशन की है और साथ ही आंदोलन फीका.
यहाँ मजा हिस्सा आता है. "1 ठोस" समय का एक गुच्छा (या बस "बहु COMP") खुला और पूर्वावलोकन के COMP डुप्लिकेट. याद है - क्या तुम सच में जल्दी से नियंत्रण का उपयोग करके ऐसा कर सकते हैं + D शॉर्टकट (कमांड + घ के पर MAC ). अब जब आप पूर्वावलोकन वहाँ गतिविधि का एक हड़बड़ी है. प्रत्येक परत के लिए यादृच्छिक संख्या भले ही भाव बिल्कुल प्रत्येक के लिए एक ही है अलग हैं.
अब चीजें अधिक दिलचस्प हो रहे हैं
खुले "मज़ा COMP" और यह पूर्वावलोकन. इस COMP के लिए, मैं "ठोस दोहराया 1" दो बार और फिर एक के Illustrator फाइलों के साथ प्रत्येक ठोस के स्थान पर. तो मैं हर बार की परतें एक गुच्छा के दोहराया. आपको लगता है कि एक बार आप भाव स्थापित किए हैं देख सकते हैं, परतों duplicating जल्दी से अपने COMP की जटिलता कहते हैं.
इसे जल्दी से इन भाव के साथ एक जटिल COMP बनाने के लिए आसान है
तुम कैसे वे काम को देखने के लिए इस भाव काटना कर सकते हैं, या तुम सिर्फ नकल कर सकते हैं और अपने खुद के comps पेस्ट. मैं (स्थान दिया है कि तीन उदाहरण, मत पारदर्श, और रोटेशन) तुम कैसे अन्य संपत्तियों के लिए अभिव्यक्ति दर्जी की एक बहुत अच्छा विचार देना चाहिए. मैं इस इन के साथ आस पास खेलने के लिए और बहुत कुछ ठंडा बना आप में से कुछ प्रेरित आशा!
# # Dan ebberts
इस पर इस तकनीक के बारे में बात करने के लिए स्वतंत्र महसूस After Effects फोरम यहाँ पर Creativecow.
|
