آموزش کدنویسی Experssion (جاوا اسکریپت) در افترافکت

[sajjadkhati]

سلام
این آموزش متنی هست
بعد اینکه سطح آموزشش مبتدی و برای پارسال هست که یه کمی افترافکت کار میکردم و گفتم آموزشش هاشو (ولو مبتدی) بزارم شاید به درد یکی بخوره. این آموزش ها خیلی وقت هه آپدیت نشد چون خیلی وقته افترافکت (و نرم افزار های میکس و مونتاژ) کار نمیکنم :



اول از همه نکته ی بسیار مهمی رو بگم اونم لینک توابع و مثال ها ی کدنویسی افترافکت رو از اینجا و لینک توضیح نوع دستورات برنامه نویسی رو در اینجا میتونین تو آدوب ببینین (زبان اش هم جاواست. باید با قند شکن لینک ها (سایت آدوب) رو باز کنین)

هر از گاهی اگه توابع و کد نویسی افترافکت (که به زبان جاوا هست) رو یاد گرفتم ، اینجا میزارم
کسایی که کلا با ساختار کدنویسی و برنامه نویسی آشنا نیستن ، بهتره با یکی از زبان ها کار کنن
تا جایی که من یه کم زبان ها رو میدونم ، جاوا و لوا خیلی شباهت دارن به هم. به کدنویسی در افترافکت ، Expression میگن
همونطور که میدونین و در فیلم گفته شد ، برای شروع کدنویسی در افترافکت ، کلید Alt رو پایین نگه میدارین و بعد بر روی آیکون ساعت (همون علامت کی فریم) کنار یکی از پارامترها یا ویژگی ها (منظورم از پارامتر یا ویژگی ، هر چیزی که مقدار عددی داره و علامت آیکون ساعت داره مثل rotation و opacity و هر چیز دیگه ای ...) کلیک میکنین
بازم همونطور که میدونین در برنامه نویسی هر جا از علامت پرانتز استفاده شد ، اون چیز ، تابع هست که میتونین برای آشنایی با ساختار تابع ها با برنامه نویسی آشنا شین . و اینکه هر تابع ، پارامتر یا آرگومانی رو به عنوان ورودی داره


تابع linear :

یکی از توابع پرکاربرد تو افترافکت هه . کار این تابع اینه که در یک رویداد (منظورم از رویداد، هر چیزی که مقدار عددی داره و علامت آیکون ساعت داره مثل time (که زمان در حال سپری شدن هست) یا rotation (مثلا مقدار عددی میشه به این داد و گفت 45 درجه بچرخ) یا opacity و هر چیز دیگه ای ...) ، یک کاری رو انجام بده . در واقع اگه تعریف کامل ترش رو بخاین اینه که در بازه ای از یک رویداد یا پارامتر (چون همونطور که گفتم ، پارامتر یا رویداد باید از نوع عددی باشه مقدارش پس یه بازه میشه براش تعریف کرد . مثلا فرض کنید زمانی که بازه ی مقدار پارامتر rotation از 90 درجه تا 180 درجه تغییر کرد ) ، اون پارامتر یا رویدادی که توش هستیم و توش داریم کد مینویسیم (یعنی با نگه داشتن دکمه ی alt و کلیک روی آیکون زمان یا کی فریم اش شروع کردیم به کد نوشتن) مقدارش از یه چیزی به چیز دیگه تغییر کنه (چون توی رویدادی میتونیم کد بنویسیم که مقدار عددی باشه)
به مثال شفاهی اینه که مثلا وقتی مقدار پارامتر rotation از 90 به 180 درجه تغییر کرد (یعنی هر وقت مقدار rotation از 90 شروع شد . نه اینکه قبل از 90) ، در این بازه مقدار opacity اش از 100 تا 30 تغییر کنه

آرگومان های تابع :
این تابع دارای 5 تا آرگومان داره
1) اولین آرگومان، نام رویدادی هست که میخایم هر وقت تغییر کرد ، عمل خاصی اتفاق بیفته (در مثال بالا ، همون rotation هست). فقط دقت کنیم که نام رویداد رو با حروف کوچیک بنویسیم چون اغلب زبان های برنامه نویسی از جمله جاوا به این حروف حساس اند (حالا این مهم نیست که تو افترافکت همون رویدادها اول حرف شون با حرف بزرگ نوشته میشه)
2) توی دومین آرگومان ، حداقل مقدار آرگومان اول رو میدیم (یا همون مقدار اولیه ی آرگومان اول رو میدیم که در مثال بالا همون 90 هست) . یعنی هر وقت مقدار rotation از 90 شروع شد
3) توی سومین آرگومان ، حداکثر مقدار آرگومان اول رو میدیم (یا همون مقدار آخریه ی آرگومان اول رو میدیم که در مثال بالا همون 180 هست) . یعنی هر وقت مقدار rotation تا 180 ختم شد
4) توی چهارمین آرگومان ، حداقل مقدار یا در واقع همون مقدار اولیه ی پارامتر یا رویدادی رو میدیم که توش کد داریم مینویسیم (که اون رویداد عملی میشه) . در مثال بالا ، این کد رو باید توی رویداد opacity بنویسیم و مقدارش همون 100 هست (یعنی مقدارش از 100 تغییر میکنه)
5) توی آرگومان آخر هم ، حداکثر مقدار یا در واقع همون مقدار آخریه ی پارامتر یا رویدادی رو میدیم که توش کد داریم مینویسیم (که اون رویداد عملی میشه) . در مثال بالا ، این کد رو باید توی رویداد opacity بنویسیم و مقدارش همون 30 هست (یعنی مقدارش تا 30 ختم میشه)

عملی که در نهایت انجام میشه ، رویدادی هست که اون کد رو توش داریم مینویسیم و مقدار این رویداد هم توی دو آرگومان آخر یعنی آرگومان های 4 ام و 5 ام مشخص میشه . پس این دو آرگومان ، به عنوان خروجی این تابع هستند و چون مقدارشون در حال تغییر بین این دو مقدار هست پس مقدار ثابتی در زمان خاص ندارن
و همینطور میدونیم در هر زبونی بین آرگومان های توابع باید ویرگول گزاشت که از هم جدا شن و اول و آخر اون تابع رو پرانتز گزاشت به عنوان علامت تابع

پس با این حال اگه بخایم همون مثال rotation ای رو که در بالا گفته شد رو عملی بنویسیم :
اول چون میخایم مقدار opacity مون عوض شه ، پس این کد رو توی پارامتر opacity مینویسیم. دوم اینکه میخایم پارامتر rotation هر وقت تغییر کرد ، این عمل انجام شه ، پس آرگومان اول رو rotation مینویسیم (با حروف کوچیک). چون میخایم هر وقت مقدار rotation از 90 به 180 تغییر کرد ، مقدار opacity هم از 100 کم شه و تا 30 تغییر کنه ، به ترتیب توی پارامترهای دوم تا پنجم ، عددهای 90 و 180 و 100 و 30 رو مینویسیم :

linear(rotation,90,180,100,30)

حالا کافیه که مقدار rotation رو از 90 آروم آروم بیشتر کنین و تا 180 برسونین ، میبینین که opacity اش هم داره کم میشه آروم آروم
تذکر : وقتی توی رویدادی (در اینجا opacity) کدی نوشتیم ، دیگه نمیشه مقدار این رویداد رو تغییر داد چون تابع کد ما میشه پس در اینجا دیگه نمیشه میزان شفافیت رو خودمون هر وقت دلمون خلست برای این لایه دستکاری کنیم
این مشخصه که اگه هر وقت رویدادی که تو آرگومان اول فراخونی کردیم ، برعکس شه مقدارش ، مقدار عمل انجام شده هم بر عکس میشه و به مقدار اولیه ی خودش برمیگرده یعنی در مثال بالا اگه rotation رو که از 180 گذشته شد رو هر وقت کمتر از 180 کنیم دوباره ، مقدار opacity هم بر عمس میشه و اگه rotation به 90 برسه opacity هم به 100 میرسه آروم آروم

یه مثال دیگه اینکه هر وقت زمان از 5 امین ثانیه به 8 امین ثانیه رسید ، opacity از 0 به 100 برسه :
برای این کار چون پارامتر زمان دیدنی نیست ، هر جا خاستیم از زمان استفاده کنیم ، از کلمه ی time استفاده میکنیم

linear(time,5,8,0,100)

حالا کافیه که زمان رو از 5 ثانیه تا 8 امین ثانیه ببرین ، میبینین که opacity اش هم داره بیشتر میشه آروم آروم
در کل کار این تابع خیلی شبیه عملکرد if تو زبان برنامه نویسی هه (یعنی اگه شرط خاصی برقرار بود ، عمل خاصی رو انجام بده منتها این یه رنج خاص داره که دیدیم) . هر چند توی زبان جاوا هم ساختار if خودش هست (خواستم بگم عملکرد این تابع بیشتر به چی شبیه هه)

[sajjadkhati]

فراخونی پارامتر (ویژگی ها) کامپوزیشن و لایه های دیگه :

باز هم تکرار کنم برای قسمت فراخونی و کلا ساختار کدنویسی به این لینک مراجعه کنین (که به این پست مربوط میشه) و برای آشنایی با توابع ، به این لینک

یکی از مبحث های بسیار مهم برای هر کد نویسی ای ، فراخونی هست. حالا توی اینجا فراخونی لایه ها و کامپوزیشن هاست و فراخونی ساختار برنامه نویسی مثل تابع یا آرایه نیست
مثلا فرض کنین تو مثال پست بالا ، که کداش به این سبک عمل میکنه که هر وقت مقدار rotation همون لایه از 90 به بالا بره ، مقدار opacity تغییر میکنه ، حالا فرض کنید میخاید وقتی مقدار rotation یک لایه ی دیگه تغییر کنه ، میزان opacity لایه ی مورد نظر ما تغییر کنه . یا فرضا هر وقت لایه ی خاصی که توی یک کامپوزیشن خاص دیگه ای که وجود داره تغییر کنه ، مقدار لایه ی فعلی مون (که توی یه کامپوزیشن دیگه هست) تغییر کنه
برای این کار لازم دارین که فراخونی لایه ها و کامپوزیشن ها رو یاد بگیرین که آسون هم هست

اگه بخاین یه لایه ی دیگه بجز اون لایه ای که دارین روش کد نویسی میکنین رو فراخونی کنین ، باید کل ساختارش رو با اسم یا در صورتی که شماره داره و خواستیم ، با شماره یا روش های دیگه فراخونی کنیم و بین هر فراخونی علامت نقطه بزاریم
منظور از کل ساختار اینه که به ترتیب ، نام کامپوزیشن و بعد نام لایه و بعد نام افکت و بعد پارامتر یا ویژگی اون افکت فراخونی شه و بین فراخونی کامپوزیشن و لایه و افکت و پارامتر ، علامت نقطع بزاریم (یکی از نشانه های آرایه ، علامت نقطه هست)
البته گاهی اوقات میشه کل ساختارش هم نام نبریم (مثلا اگه ویژگی rotation رو نام میبریم ، لازم نیست اسم افکت اش که transform هست را نام ببریم اما احتمالا وقتی افکت ای که خودمون اضافه میکنیم ، باید اسم اش رو ببریم پس بهتره عادت به کامل نوشتن کنیم)
ضمنا همونطور که قبلا گفته شد ، نام افکت ها و یا ویژگی ها رو حتما باید با حروف کوچیک نوشت

برای فراخونی کامپوزیشن ، کلمه ی comp (با حروف کوچیک) رو مینویسیم و بعد از گزاشتن پرانتز (پس تابع هست) ، نام کامپوزیشن (حتما باید عین اسم خود کامپوزیشن با رعایت تمام حروف های بزرگ و کوچیک بنویسیم) رو بین علامت رشته که دو تا علامت " " هست مینویسیم
دقت داشته باشین که نام یه چیزی (مثل نام کامپوزیشن یا نام لایه و ...) که به عنوان رشته توی دو تا علامت " " فراخونی میشه ، باید عین نام اصلی با رعایت حروف کوچیک و بزرگ باشه اما نام تابع (در اینجا کلمه ی comp یا در جلوتر کلمه های rotation و ... که میرسیم) باید کلا با حروف کوچیک باشن
فرض کنید نام کامپوزیشن من هست Copm 1 (با C بزرگ و یه فاصله داره تا 1) پس تا اینجا میشه :

comp("Comp 1")

اولین comp با c کوچیک که نام تابع ام هست و Comp 1 که دقیق باید همینطور نوشته بشه بین دو علامت " " به عنوان رشته ، اسم کامپوزیشن ام هست
بعد از این نوبت میرسه به فراخونی نام لایه منتها قبل اش باید از علامت نقطه بین شون استفاده کرد (یعنی آرایه) چون نوع فراخونی ما عوض داره میشه و از نوع کامپوزیشن به نوع لایه داریم میرسیم. لایه هم دقیق مثل فراخونی کامپوزیشن هه فقط فرقش اینه که بجای کلمه ی comp از کلمه ی layer (با حروف کوچیک) استفاده میشه . فرض کنید اسم لایه ی من tasvir tabiat.jpg هست (دقت کنین وقتی عکس یا هر چیزی میزارین تو پروژه ، بصورت اتوماتیک پسوند فایل هم به عنوان اسم اش انتخاب میشه که میتونین بصورت دستی اونو تغییر نام بدین و پسوند فایل رو از اسم لایه توی پروژه حذف کنین) و به عنوان دومین لایه ی من هست
پس تا اینجا میشه :

comp("Comp 1").layer("tasvir tabiat.jpg")

تذکر : همونطور که میدونیم ، هر لایه ، شماره ای داره و ما میتونیم برا فراخونی ، بجای اینکه اسم لایه رو به عنوان رشته توی " " بنویسیم ، بدون استفاده از این علامت (شماره هایی رو که به عنوان عدد هستند ، توی رشته نمیزارن) شماره ی لایه رو بنویسیم که این روش راحت تره و پیشنهاد میشه. فقط همونطور که گفته شد باید دقت کنیم چون عدد لایه ، اسم نیست پس نباید توی علامت رشته " " که نام رشته رو مشخص میکرد بزاریم
چون فرض کردیم این لایه tasvir tabiat.jpg ، دومین لایه ی من هست پس میتونیم بجای خط بالا بنویسیم :

comp("Comp 1").layer(2)

باز هم تاکید میشه که دقت کنین ، شماره ی لایه ، توی علامت رشته "" قرار نگرفت
بعد هم نقطه میزاریم و بعد اسم یا همون نوع افکت مورد نظرمون که transform بود (چون اسم افکت به عنوان تابع هست پس نباید توی علامت رشته که "" هست قرار بگیره و باید هم تمام حروف هاش کوچیک باشن حتی اگه اسم اش توی افترافکت با حرف اول بزرگ نوشته شده باشه). پس :

comp("Comp 1").layer(2).transform

هر چند نام افکت در اینجا مهم نیست اما پیشنهاد اینه که بهتره کامل بنویسیم تا عادت کنیم
باز هم نقطه و بعد نام ویژگی یا همون پارامتر مورد نظر رو مینویسیم (باز هم چون تابع هست با حروف کوچیک) . چون همون مثال پست بالا رو میخایم کار کنیم ، و مثال ما هم rotation بود پس میشه :

comp("Comp 1").layer(2).transform.rotation

این از آرگومان اول اش بود . بقیه ی آرگومان مثال پست بالا که بود :

linear(comp("Comp 1").layer(2).transform.rotation ,90,180,100,30)

اگه این کد رو توی ویژگی opacity لایه ی اول (فرض میکنیم اونم تصویر یا هر چیز دیگه ای هست) بزاریم و لایه ی دوم هم که مشخص بود که تصویره وقتی تصویر در لایه ی دوم داخل کامپوزیشن Copm 1 رو از 90 درجه بیشتر بچرخونیم ، شفافیت لایه ی اول آروم آروم کم میشه (تا 30 درصد میرسه اگه چرخش لایه ی دوم به 180 درجه برسه)


همونطور که توی لینک توابع که داده شد مشخص هه ، اگه کامپوزیشن ای که فراخونی میکنیم ، توی همون کامپوزیشن ای هست که داریم کد نویسی میکنیم ، میشه بجای قسمت فراخونی کامپوزیشن (که شامل نام اش هم میشد) از تابع با کلمه ی this_comp (قسمت comp با C کوچیک و آندرلاین بین شون) و یا بجای این هم از کلمه ی thisComp (بدون آندرلاین و حتما با C بزرگ برای کلمه ی Comp اما کلمه ی this با t کوچیک) میشه استفاده کرد که دیگه از نوشتن نام کامپوزیشن خلاص شیم.
این مثال بالا هم این طوری در نظر گرفته شده که هر دو لایه توی یه کامپوزیشن ان پس میشه بجای خط بالا هم نوشت :

linear(thisComp.layer(2).transform.rotation ,90,180,100,30)

یا

linear(this_comp.layer(2).transform.rotation ,90,180,100,30)

برای لایه هم این کلمه ی کلیدی صادق هست اما چندان کاربرد نداره یعنی this_layer یا thisLayer


فراخونی ویژگی ها و پارامترهایی که چند مقدار دارند (مهم) :

فرض کنید میخاین یه ویژگی و پارامتری رو که 2 تا مقدار داره مثل position که هم مقداری برای x و هم مقداری برای y داره رو فراخونی کنین. یا اگه لایه ای رو 3 بعدی کنین ، تعداد position به 3 تا هم میرسه . در این صورت چی؟
برای قسمت هایی که بیش از یکی هستند (حالا میخاد یه بار به عنوان x و y و z باشن یا هر چیز دیگه ای) هر کدوم شون به ترتیب داخل آرایه ی خاص میرن که این آرایه ها از صفر شروع میشه (مثل زبان ++C از صفر شروع میشن این آرایه ها) . علامت آرایه هم کلوشه هست [ ] و شماره ی مورد نظر رو توش باید بنویسیم. چون position 3 مقدار داره (در صورت 3 بعدی بودن یا 2 مقدار در صورت 2 بعدی بودن) پس جلوی اسمش علامت کلوشه باز میکنیم . چون شماره گزاری این آرایه ها از صفر شروع میشد ، اگه منظور ما x بود ، شماره ی 0 و اگه y بود شماره ی 1 و اگه z بود شماره ی 2 رو توی کلوشه مینویسیم. پس [0]position یعنی مقدار x منظورمون هست و [1]position یعنی مقدار y منظورمون هست و [2]position یعنی مقدار z منظورمون هست (حواسمون به شماره گزاری آرایه ها باشه که از 1 شروع نمیشه ها)
پس اگه خاستیم مثلا بگیم تو لایه ی دوم هر وقت بازه ی x (منظور همون position) از 500 تا 800 تغییر کرد ، شفافیت لایه ی اول هم از 100 به 20 تغییر کنه ، مینویسیم :

linear(thisComp.layer(2).transform.position[0] ,500,800,100,20)

حالا اگه position لایه ی دوم رو بین بازه ی 500 تا 800 تغییر بدیم ، لایه ی اولی شفافیت اش به همون نسبت تغییر میکنه
اگه کدی رو اشتباه بنویسیم ، بعد از نوشتن ، علامت اخطار زرد رنگ سمت چپ اش ظاهر میشه که با زدن اش توضیح رفع خطا توش هست
این دیگه بدیهی هست که وقتی کد بالا رو نوشتیم ، میخاین تو خروجی فیلم کار کنه ، اول باید برای position محور x لایه ی دوم ، کی فریم ای درست کنیم که مثدارش بین 500 تا 800 تغییر کنه و بعد نتیجه رو ببینیم توی شفافیت لایه ی اول

یه تذکر دیگه عمومی تو برنامه نویسی بگم که بعد از تموم شدن تابع (مثلا بسته شدن پرانتز تابع linear) اگه بخایم تابع یا کد دیگه ای بنویسیم باید آخر تابع قبلی علامت ; بزاریم
به این توابعی که هم تابع ان و هم داخل آرایه هستن (علامت دات یا کلوشه دارن) ماژول گفته میشه
در آرگومان های 2 تا پنجم linear میشهبجای عدد ، متغییر یا آرایه یا تابعی که مقدار بازگشتی شون عدد باشه ، استفاده کرد
برای درک بیشتر این نکات 3 خط آخر ، بهتره آموزش لوا که تو انجمن هست رو بخونین

[sajjadkhati]

آرایه ها :

خلاصه اینکه توی افترافکت (جاوا اسکریپت) اگه میخاین به ویژگی ای (مثلا Rotation و یا هر ویژگی دیگه ای که کلا قابلیت ساخت کی فریم رو داشته باشه) مقدار بدین ، باید از آرایه ها استفاده کنین. البته اگه پارامتری ویژگی ای فقط یک مقدار بخاد (مثلا مثل ویژگی Opacity که فقط یک مقدار میخاد ، میتونین از متغییرها هم استفاده کنین . یعنی در این حالت هم میشه از آرایه ها استفاده کرد و یا هم از متغییرها اما برای ویژگی هایی که بیشتر از یک مقدار دارن ، باید از آرایه ها استفاده کرد مثل ویژگی Rotation یا Position که هم پارامتری برا X و هم Y و اگه 3 بعدی هم باشه برای Z داره)
اینکه برای آرایه ها یا متغییرها ، اسم بزاریم با نزاریم ، هیچ فرقی تو نتیجه نداره.
نکته ی مهم دیگه اینکه اگه تو ویژگی ای (مثلا Rotation) ، متغییر یا آرایه ای تعریف کردیم ، نام این آرایه یا متغییر ، توی حوزه ی ویژگی دیگه (مثلا در حوزه ی Position) قابل شناسایی و تعریف شده نیست و نمیشه اون متغییر یا آرایه رو اونجا فراخونی کرد (البته تا جایی که من تست کردم . خبر بدی هم هست و اگه کسی روش حل کردن یا فراخونی متغییر توی ویژگی های دیگه رو متوجه شد ، ممنون میشم بگه)
آرایه رو توی علامت [ ] توی جاوا اسکریپت یا همون زبون برنامه نویسی افترافکت میزارن (توی لوا و ++C توی علامت { } میزارن) . عضوهای هر آرایه ، با علامت ویرگول از هم جدا میشن

حالا یه چن تا مثال :
توی ویژگی Opacity بنویسین :

[30]

همین ، تموم . این باعث میشه مقدار Opacity شی تون 30 درصد بشه
چون توی علامت [ ] هست ، یعنی آرایه هست. چون عدد دیگه ای با ویرگول ازش جدا نشد ، پس یعنی یک مقدار داره پس میشه بجای اینکه آرایه بنویسیم ، توی متغییر بنویسیم
این خط بالا ، هیچ فرقی نداره که برای آرایه یا متغییر ، اسمی بزاریم مثلا :

Array=[30]

این دقیق همون کار رو میکنه که خط بالاترش میکرد ، فقط مقدار آرایه رو توی Array ذخیره میکنه
همونطور که میدونین ، توی اغلب برنامه نویسی ها ، مثل ++C و جاوا اسکریپت ، اندیس یا شماره ی آرایه ها از صفر شروع میشه تا تعداد مقدارشون منهای یک . یعنی برای فراخونی آرایه ها که در اون موقع باید از اندیس استفاده کنیم ، از صفر باید شماره گزاری بشن تا تعداد آرایه ها منهای یک (لوا از صفر نیست ، دلتون آب )
تیک 3 بعدی یک لایه رو بزنین و توی ویژگی Position اش این رو بنویسین :

Pos=[700,300,100];

همونطور که مشخصه ، آرایه ی Pos ، سه مقدار داره که به ترتیب مقدار اول اش که برای X بود ، 700 و مقدار دومش که برای Y بود ، 300 و مقدار سومش که برای Z بود ، 100 هست. برای فراخونی آرایه با 3 عضو همونطور که گفته شد ، عضو اول رو که 700 هست بخایم فراخونی کنیم ، درسته که اولین عضو هه اما زبان اونو به عنوان صفر امین عضو میشناسه پس برای فراخونی عضو اول که مقدار 700 برای پارامتر X هست ، باید بنویسیم :

Pos[0]

حالا صفرامین عضوش که مقدار اولی که 700 بود ، هست ؛ اولین عضوش میشه مقدار دومی که 300 که برای پارامتر Y و همینطور دومین عضوش هم مقدار سومی که 100 که برای Z هست میشه
پس عضو های آرایه ها کلا از صفر شروع میشه تا همینطور میریم بالا :

Pos[0];
Pos[1];
Pos[2];

متغییر و آرایه ی value :
اول بگم value با همه ی حروف کوچیک هستا (چون زبان ها به حروف کوچیک و بزرگ حساس ان)
متغییر یا آرایه ی میشه گفت رزرو شده هست که مقدار همون ویژگی ای که توش فراخونی شد رو برمیگردونه. مثلا اگه توی ویژگی Opacity فراخونده بشه و نوشته بشه ، همون مقداری که Opacity داشت رو برمیگردونه (فرضا مقدار Opacity بود 50 درصد ، متغییر value مقدارش 50 درصد میشه) و اگه توی ویژگی Rotation نوشته شه ، همون مقادیر های این ویژگی رو برمیگردونه (البته در قسمت Rotation چون چند پارامتر داره در ادامه توضیح داده میشه)
کلمه ی value هم میتونه متغییر باشه و هم آرایه . در جاهایی که اون ویژگی ، یک پارامتر داره (مثل Opacity) به عنوان متغییر هست و در جاهایی که بیش از مقدار باشه (مثل Rotation و ...) ، به عنوان آرایه هست که باید در این صورت با اندیس فراخونی شه (در اینجا اشتباه گرفتن value به عنوان متغییر یا پارامتر (یعنی اینکه بدون اندیس فراخونی کنیم یا با اندیس) موجب ارور میشه ها . حواسمون باشه) یعنی در این صورت ، در Rotation ، برای فراخونی پارامتر X اش value[0] و برای Y اش value[1] و برای Z اش value[2] رو مینویسیم

مطمئن شین تیک 3 بعدی یه لایه زده هه . توی ویژگی Position مقادیرشو به ترتیب X و Y و Z رو بدین 700 و 300 و 100 و بعدش این کد رو بدین :

[value[0],value[1],value[2]];

همونطور که میبینین ، هیچ تغییری با دادن کد وضعیت Position هاش نکرد چون مقدار اولی که value[0] که برای X و 700 بود رو برای عدل برای خود X میزاره و همینطور مقدار Y و Z رو که 300 و 100 بودن رو برای خودشون میزاره (چون همون ها بودن ، هیچ تفاوتی نکردن وضعیت شون)
در ادامه برای درک بیشتر مثال های بیشتری زده میشه اما قبل اش عملیات ریاضی روی آرایه ها رو بگم

عملیات ریاضی روی آرایه ها :
اگه هر عضو با مقداری ، عمل ریاضی روش بصورت مجزا انجام شه که هیچ . مثل این که مشخصه :

[value[0]+100,value[1]+200,value[2]+300];

اما اگه عملیات ریاضی ، قبل یا بعد از آرایه انجام بشه ، در همه ی حالات اون عدد یا عددهای قبل یا بعد از آرایه ، فقط با صفرامین عضو از آرایه عملیات انجام میده بجز زمانی که کل یه آرایه (نه فقط عضو خاصی از آرایه که همون در حقیقت یک عدد میشه) رو با آرایه ی دیگه عملیات ریاضی انجام بدیم.
همونطور که تو خط های بالا گفته شد ، پارامترهای X=700 و Y=300 و Z=100 تنظیم کردیم ؛ پس :

500+[value[0],value[1],value[2]];

عدد 500 رو با صفرامین عضو که value[0] که همون مقدار X که 700 بود رو جمع میکنه و میزاره بجای value[0] یا همون صفرامین عضو آرایه . پس مقدار X بجای 700 ، میشه 1200

value[1]+[value[0],value[1],value[2]];

مقدار عدد قبل از آرایه رو که value[1] که 300 هست را با صفرامین عضو از آرایه که 700 هست جمع میکنه و توی صفر امین عضو از آرایه که همون مقدار X بود ، جایگزین میکنه که میشه 1000
اما اگه کل یه آرایه (بدون مشخص کردن عضو خاصی از اون) رو با یه آرایه ی دیگه جمع کنیم (منظورم اینه که کلا عملیات ریاضی روشون انجام بدیم) ، صفر امین عضو از آرایه ی اول رو با صفر امین عضو از دومین آرایه جمع میکنه و مقدارش رو توی صفرامین عضو آرایه میزاره و اولین عضو از هر دو آرایه رو جمع میکنه و توی اولین عضو از آرایه میزاره و همینطور تا آخر ...
پس :

value+[value[0],value[1],value[2]];

همونطور که گفته شد ، قبل از آرایه (علامت براکت) که value اومد و چون value توی Position اومد ، و Position هم 3 تا پارامتر داره (بیش از یکی) پس value آرایه هست (متغییر نیست) که 3 مقدار داره . خودش باز با آرایه ای که 3 مقدار جداگانه داره که این هست :

[value[0],value[1],value[2]]

جمع شد . پس چون دو تا آرایه جمع شدن ، صفر امین عضو از هر دو آرایه با هم جمع میشن و در مقدار آرایه ی نهایی ذخیره میشن و همینطور مقدار اولین و دومین عضو از آرایه هم همینطور . پس همه ی عضو ها چون با مقدار خودشون جمع میشن ، در اینجا در واقع هر عضو ضربدر 2 میشه . پس مقدار X میشه 1400 و Y=600 و Z=200 میشه

یه مثال دیگه اینکه داخل همین Position ، این کد رو بنویسین :

temp = transform.opacity;
temp =temp *7;
[temp, temp, temp]

در واقع کد بالا ، مقدار opacity رو میگیره هر وقت تغییر کنه و توی متغییر temp میریزه (چون Opacity یه دونه پارامتر فقط داره ، پس temp متغییر میشه نه آرایه) تو خط دوم متغییر temp هفت برابر میشه و این متغییر توی هر 3 پارامتر X و Y و Z به عنوان Position جایگزین میشه . مثلا اگه مقدار Opacity رو 50 کنیم (یا اگه برای Opacity کی فریم درست کنیم هم که برای Position هم کی فریم درست میشه) position برای X و Y و Z هر 3 تاشون 350 میشن
اگه توی Position فقط یک مقدار رو خواستیم که برابر متغییر temp بشه (مثلا مقدار Y رو این طور خواستیم) و بقیه X و Z همون مقداری که هستن بمونن ، مشخصه که میتونیم بجای X و Z یعنی بجای صفرمین و دومین (اولین و آخرین) عضو آرایه ، آرایه ی valu[0] و value[2] رو بکار ببریم که باعث میشه صفرمین عضو از آرایه که X و برابر 700 بود ، همون بمونه و همینطور دومین (آخرین) عضو آرایه که 100 بود هم همین مقدارش بمونه و فقط مقدار temp (که 300 بود) جایگزین Y میشه :

temp = transform.opacity;
temp =temp *7;
[value[0], temp, value[2]]

این گفته شد که در خط آخر کد بالا اگه بجای valu[0] یا value[2] فقط value بزاریم ، چون آرایه هست (و بسته ای از اعداد رو فراخونی کردیم و عدد مشخصی رو فراخونی نکردیم) ، ارور میگیریم

[sajjadkhati]

تو قسمت Expression Control ، افکت Slider Control خیلی کاربردی برای کدنویسی افترافکت (Expression) هست و برای ایجاد کیفریم برای کدنویسی کاربرد داره که میتونیم از مقدار ویژگی slider در این افکت به عنوان متغییر (یا همون مقدار عددی) در هر تابع استفاده کنیم و از طرفی هم برای این ویژگی کیفریم درست کنیم که چون کیفریم درست کردیم و مقدارش تغییر میکنه و از طرفی هم به عنوان متغییر این مقدار رو توی آرگومان تابع دیگه استفاده کردیم ، مقدار اون آرگومان هم تغییر میکنه . البته بجز افکت Slider Control برای هر افکت دیگه ای میشه کیفریم درست کرد و مقدارش رو به عنوان متغییر در آرگومان هر تابعی استفاده کرد ولی این کار ممکنه چون روی بقیه ی افکت ها تاثیر بزاره ، پس منطقی نباشه ولی افکت Slider Control مقدارش روی چیزی تاثیر نمیزاره پس مخصوص Expression ها و توابع ها هست

تابع wiggle برای تغییر مقدار تصادفی (ایجاد نوسان) برای اون ویژگی خاص (مثلا opacity یا position و هر ویژگی دیگه که قابلیت ایجاد کیفریم داره) هست (که برای position باعث ایجاد تغییرات تصادفی مقدارش و لرا باعث ایجاد لرزش میشه)

تابع بسیار کاربردی valueAtTime(time) هم که قبلش با پسوند یک مقدار عددی (که میتونه opacity یا position و هر افکت و ویژگی دیگه ای که عدد داره) فراخونی میشه یعنی عدد یا متغییر یا آرایه ی عددی مورد نظر نوشته میشه و بعدش نقطه گذاشته میشه و بعدش این تابع بالا نوشته میشه (به قول معروف توی #C به این توابع ، توابع Extension میگن. تو جاوا اسکریپت نمیدونم)

transform.position.valueAtTime(time)

ورودی این تابع هم فقط متغییر time رو میپذیره نه عدد یا حتی متغییر و آرایه ی عددی دیگه ای رو و اگه بخوایم تاخیر بندازیم ، فقط کافیه بعد از time تعداد ثانیه های مورد نظر رو بنویسیم مثلا کد زیر 5 ثانیه تاخیر میندازه و همون عمل و تابع رو اجرا میکنه (و اون عدد رو برمیگردونه) یعنی بعد از 5 ثانیه مقدار position اون لایه ای که بهش اشاره میشه (که در اینجا خود position همون لایه هست) رو برمیگردونه :

transform.position.valueAtTime(time-5)

[sajjadkhati]

این هم برای کدنویسی افترافکت خوبه :

https://cgi.tutsplus.com/tutorials/i...ting--ae-22518

و مهم تر اینکه این سایت زیر برای رفرنس ها و راهنمای توابع افترافکت هست :

http://expressions.aenhancers.com/footage.html