DayZ 1.26
DayZ Explorer by KGB
Загрузка...
Поиск...
Не найдено
Структуры данных | Функции | Переменные
Файл PPEMatClassParameterFloat.c

См. исходные тексты.

Структуры данных

class  PPEMatClassParameterCommandData
 

Функции

class PPEMatClassParameterFloat extends PPEMatClassParameterCommandData PPEMatClassParameterFloatSaturation (int mat_idx, int parameter_idx, PPEClassBase parent)
 
void PPEMatClassParameterFloat (int mat_idx, int parameter_idx, PPEClassBase parent)
 
override void InitDefaults ()
 
override void InitCuttent ()
 
override int GetParameterVarType ()
 
override void Update (float timeslice, out Param p_total, out bool setting_defaults, int order)
 
void PrepareLayerInfo (int layer, float value, int operator)
 
override void SetParameterValueDefault (inout Param p_total)
 No active requests for the mat. parameter value change, sets the value to DEFAULT (zero?)
 

Переменные

ref map< int, ref array< float, int > > m_LayerInfo
 
PPETemplateDefFloat m_Float
 
float m_ValueDefault
 
float m_ValueMin
 
float m_ValueMax
 

Функции

◆ GetParameterVarType()

override int GetParameterVarType ( )
protected

◆ InitCuttent()

override void InitCuttent ( )
protected
267{
268 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
269
270 protected PPETemplateDefFloat m_Float;
271 protected float m_ValueDefault;
272 protected float m_ValueMin;
273 protected float m_ValueMax;
274
275 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
276 {
277 m_LayerInfo = new map<int,ref array<float,int>>;
278 }
279
280 override void InitDefaults()
281 {
282 Class.CastTo(m_Float,m_Defaults);
283 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
284 m_ValueDefault = m_Float.param2;
285 m_ValueMin = m_Float.param3;
286 m_ValueMax = m_Float.param4;
287 }
288
289 override void InitCuttent()
290 {
291 m_CurrentValues = new Param1<float>(m_ValueDefault);
292 }
293
294 override int GetParameterVarType()
295 {
296 return PPEConstants.VAR_TYPE_FLOAT;
297 }
298
299 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
300 {
301 super.Update(timeslice,p_total,setting_defaults,order);
302
303 int active_request_count = 0;
304
305 PPERequestParamDataFloat req_data;
306
307 bool setting_value_zero = false;
308
309 float float_value_temp = 0.0;
310 float float_value_default = 0.0;
311 float float_value_total = 0.0;
312
313 if (p_total == null)
314 {
315 p_total = new Param1<float>(0.0);
316 }
317
318 if (m_RequestMap.Count() > 0)
319 {
320 m_LayerInfo.Clear();
321 }
322 else
323 {
324 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
325 SetParameterValueDefault(p_total);
326 m_Parent.ParamUpdateRemove(m_ParameterIndex);
327 return;
328 }
329
330 for ( int i = 0; i < m_RequestMap.Count(); i++ )
331 {
332 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
333
334 if (req_data == null)
335 {
336 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
337 continue;
338 }
339
340 setting_value_zero = req_data.IsSettingDefaultValues();
341
342 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
343 {
344 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
345 continue;
346 }
347
348 if (setting_value_zero)
349 {
350 req_data.m_FloatTarget = 0;//min;
351 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
352 }
353 else
354 {
355 active_request_count++;
356 }
357
358 //evaluation
359 //--------------------------------
360 req_data.m_FloatLast = req_data.m_FloatCurrent;
361
362 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
363 {
364 float_value_temp = req_data.m_FloatCurrent;
365 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
366 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
367 continue;
368 }
369
370 float_value_temp = req_data.m_FloatTarget;
371
372 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
373 req_data.SetUpdatingDataValues(false);
374 if (setting_value_zero)
375 {
376 req_data.SetDataActive(false);
377 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
378 }
379 else
380 {
381 float_value_temp = req_data.m_FloatTarget;
382 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
383 }
384
385 req_data.m_FloatCurrent = float_value_temp;
386 }
387
388 //---------------------------
389 //MASK handling and calculation
390 float value;
391 int operator;
392 bool override_active = false;
393
394 if ( m_ValueMax == 0.0 )
395 float_value_total = m_ValueDefault; //?
396 else
397 float_value_total = m_ValueDefault / m_ValueMax;
398
399 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
400 float_value_default = float_value_total;
401
402 for ( i = 0; i < m_LayerInfo.Count(); i++ )
403 {
404 if ( override_active )
405 break;
406
407 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
408 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
409
410 switch (operator)
411 {
412 case PPOperators.LOWEST:
413 float_value_total = Math.Min(float_value_total,value);
414 break;
415
416 case PPOperators.HIGHEST:
417 float_value_total = Math.Max(float_value_total,value);
418 break;
419
420 case PPOperators.ADD:
421 //float_value_total = float_value_total + value - float_value_default;
422 float_value_total = float_value_total + value;
423 break;
424
425 case PPOperators.ADD_RELATIVE:
426 float_value_total = (1 - float_value_total) * value + float_value_total;
427 break;
428
429 case PPOperators.SUBSTRACT:
430 //float_value_total = float_value_total - value + float_value_default;
431 float_value_total = float_value_total - value;
432 break;
433
434 case PPOperators.SUBSTRACT_RELATIVE:
435 float_value_total = float_value_total - value * float_value_total;
436 break;
437
438 case PPOperators.SUBSTRACT_REVERSE:
439 //float_value_total = value - float_value_default - float_value_total;
440 float_value_total = value - float_value_total;
441 break;
442
443 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
444 float_value_total = value * float_value_total - float_value_total;
445 break;
446
447 case PPOperators.MULTIPLICATIVE:
448 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
449 float_value_total = float_value_total * value;
450 break;
451
452 case PPOperators.OVERRIDE:
453 float_value_total = value;
454 break;
455
456 case PPOperators.SET:
457 float_value_total = value;
458 break;
459 }
460
461 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
462 float_value_total = Math.Clamp(float_value_total,0,1);
463
464 if ( operator == PPOperators.OVERRIDE )
465 {
466 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
467 override_active = true;
468 }
469
470 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
471 }
472
473 m_CommandLayersArray.Clear();
474
475 //TODO - consider moving this up, if possible
476 if (active_request_count == 0)
477 {
478 SetParameterValueDefault(p_total);
479 }
480 else
481 {
482 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
483 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
484 }
485
486 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
487 m_Parent.ParamUpdateRemove(m_ParameterIndex);
488
489 m_CurrentValues = p_total;
490 }
491
492 void PrepareLayerInfo(int layer, float value, int operator)
493 {
494 m_LayerInfo.Set(layer,{value,operator});
495 AddPriorityInfo(layer);
496 }
497
499 override void SetParameterValueDefault(inout Param p_total)
500 {
501 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
502 m_CurrentValues = p_total;
503 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
504 }
505}
506
507class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
508{
509 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
510 {
511 m_Dependencies = new map<int,ref array<int>>;
512 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
513 }
514}
PPOperators
PPOperators
PP operators, specify operation between subsequent layers.
Definition PPEConstants.c:53
m_LayerInfo
ref map< int, ref array< float, int > > m_LayerInfo
Definition PPEMatClassParameterFloat.c:245
GetParameterVarType
override int GetParameterVarType()
Definition PPEMatClassParameterFloat.c:271
PPEMatClassParameterFloat
void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
Definition PPEMatClassParameterFloat.c:252
PPEMatClassParameterFloatSaturation
class PPEMatClassParameterFloat extends PPEMatClassParameterCommandData PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
Definition PPEMatClassParameterFloat.c:244
SetParameterValueDefault
override void SetParameterValueDefault(inout Param p_total)
No active requests for the mat. parameter value change, sets the value to DEFAULT (zero?...
Definition PPEMatClassParameterFloat.c:476
InitDefaults
override void InitDefaults()
Definition PPEMatClassParameterFloat.c:257
m_ValueMax
float m_ValueMax
Definition PPEMatClassParameterFloat.c:250
m_ValueMin
float m_ValueMin
Definition PPEMatClassParameterFloat.c:249
m_ValueDefault
float m_ValueDefault
Definition PPEMatClassParameterFloat.c:248
InitCuttent
override void InitCuttent()
Definition PPEMatClassParameterFloat.c:266
m_Float
PPETemplateDefFloat m_Float
Definition PPEMatClassParameterFloat.c:247
PrepareLayerInfo
void PrepareLayerInfo(int layer, float value, int operator)
Definition PPEMatClassParameterFloat.c:469
PPERequestParamDataFloat
void PPERequestParamDataFloat(int requester_idx, int mat_id, int param_id, int data_type=0, int priority=0, int mask=PPOperators.SET, bool relative=false)
Definition PPERequestData.c:142
m_Parent
Widget m_Parent
Definition SizeToChild.c:92
Class
Super root of all classes in Enforce script.
Definition EnScript.c:11
Math
Definition EnMath.c:7
PPEClassBase
Created once, on manager init. Script-side representation of C++ material class, separate handling.
Definition PPEMatClassesBase.c:3
Param3
Definition EntityAI.c:95
Param
Base Param Class with no parameters. Used as general purpose parameter overloaded with Param1 to Para...
Definition param.c:12
PostProcessEffectType
PostProcessEffectType
Post-process effect type.
Definition EnWorld.c:72
Error
void Error(string err)
Messagebox with error message.
Definition EnDebug.c:90
Class::CastTo
static proto bool CastTo(out Class to, Class from)
Try to safely down-cast base class to child class.
Math::Max
static proto float Max(float x, float y)
Returns bigger of two given values.
Math::Clamp
static proto float Clamp(float value, float min, float max)
Clamps 'value' to 'min' if it is lower than 'min', or to 'max' if it is higher than 'max'.
Math::Min
static proto float Min(float x, float y)
Returns smaller of two given values.
Math::Lerp
static proto float Lerp(float a, float b, float time)
Linearly interpolates between 'a' and 'b' given 'time'.
Update
proto native volatile void Update()
Definition PlayerSoundManager.c:125

◆ InitDefaults()

override void InitDefaults ( )
protected
258{
259 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
260
261 protected PPETemplateDefFloat m_Float;
262 protected float m_ValueDefault;
263 protected float m_ValueMin;
264 protected float m_ValueMax;
265
266 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
267 {
268 m_LayerInfo = new map<int,ref array<float,int>>;
269 }
270
271 override void InitDefaults()
272 {
273 Class.CastTo(m_Float,m_Defaults);
274 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
275 m_ValueDefault = m_Float.param2;
276 m_ValueMin = m_Float.param3;
277 m_ValueMax = m_Float.param4;
278 }
279
280 override void InitCuttent()
281 {
282 m_CurrentValues = new Param1<float>(m_ValueDefault);
283 }
284
285 override int GetParameterVarType()
286 {
287 return PPEConstants.VAR_TYPE_FLOAT;
288 }
289
290 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
291 {
292 super.Update(timeslice,p_total,setting_defaults,order);
293
294 int active_request_count = 0;
295
296 PPERequestParamDataFloat req_data;
297
298 bool setting_value_zero = false;
299
300 float float_value_temp = 0.0;
301 float float_value_default = 0.0;
302 float float_value_total = 0.0;
303
304 if (p_total == null)
305 {
306 p_total = new Param1<float>(0.0);
307 }
308
309 if (m_RequestMap.Count() > 0)
310 {
311 m_LayerInfo.Clear();
312 }
313 else
314 {
315 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
316 SetParameterValueDefault(p_total);
317 m_Parent.ParamUpdateRemove(m_ParameterIndex);
318 return;
319 }
320
321 for ( int i = 0; i < m_RequestMap.Count(); i++ )
322 {
323 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
324
325 if (req_data == null)
326 {
327 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
328 continue;
329 }
330
331 setting_value_zero = req_data.IsSettingDefaultValues();
332
333 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
334 {
335 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
336 continue;
337 }
338
339 if (setting_value_zero)
340 {
341 req_data.m_FloatTarget = 0;//min;
342 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
343 }
344 else
345 {
346 active_request_count++;
347 }
348
349 //evaluation
350 //--------------------------------
351 req_data.m_FloatLast = req_data.m_FloatCurrent;
352
353 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
354 {
355 float_value_temp = req_data.m_FloatCurrent;
356 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
357 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
358 continue;
359 }
360
361 float_value_temp = req_data.m_FloatTarget;
362
363 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
364 req_data.SetUpdatingDataValues(false);
365 if (setting_value_zero)
366 {
367 req_data.SetDataActive(false);
368 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
369 }
370 else
371 {
372 float_value_temp = req_data.m_FloatTarget;
373 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
374 }
375
376 req_data.m_FloatCurrent = float_value_temp;
377 }
378
379 //---------------------------
380 //MASK handling and calculation
381 float value;
382 int operator;
383 bool override_active = false;
384
385 if ( m_ValueMax == 0.0 )
386 float_value_total = m_ValueDefault; //?
387 else
388 float_value_total = m_ValueDefault / m_ValueMax;
389
390 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
391 float_value_default = float_value_total;
392
393 for ( i = 0; i < m_LayerInfo.Count(); i++ )
394 {
395 if ( override_active )
396 break;
397
398 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
399 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
400
401 switch (operator)
402 {
403 case PPOperators.LOWEST:
404 float_value_total = Math.Min(float_value_total,value);
405 break;
406
407 case PPOperators.HIGHEST:
408 float_value_total = Math.Max(float_value_total,value);
409 break;
410
411 case PPOperators.ADD:
412 //float_value_total = float_value_total + value - float_value_default;
413 float_value_total = float_value_total + value;
414 break;
415
416 case PPOperators.ADD_RELATIVE:
417 float_value_total = (1 - float_value_total) * value + float_value_total;
418 break;
419
420 case PPOperators.SUBSTRACT:
421 //float_value_total = float_value_total - value + float_value_default;
422 float_value_total = float_value_total - value;
423 break;
424
425 case PPOperators.SUBSTRACT_RELATIVE:
426 float_value_total = float_value_total - value * float_value_total;
427 break;
428
429 case PPOperators.SUBSTRACT_REVERSE:
430 //float_value_total = value - float_value_default - float_value_total;
431 float_value_total = value - float_value_total;
432 break;
433
434 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
435 float_value_total = value * float_value_total - float_value_total;
436 break;
437
438 case PPOperators.MULTIPLICATIVE:
439 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
440 float_value_total = float_value_total * value;
441 break;
442
443 case PPOperators.OVERRIDE:
444 float_value_total = value;
445 break;
446
447 case PPOperators.SET:
448 float_value_total = value;
449 break;
450 }
451
452 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
453 float_value_total = Math.Clamp(float_value_total,0,1);
454
455 if ( operator == PPOperators.OVERRIDE )
456 {
457 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
458 override_active = true;
459 }
460
461 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
462 }
463
464 m_CommandLayersArray.Clear();
465
466 //TODO - consider moving this up, if possible
467 if (active_request_count == 0)
468 {
469 SetParameterValueDefault(p_total);
470 }
471 else
472 {
473 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
474 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
475 }
476
477 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
478 m_Parent.ParamUpdateRemove(m_ParameterIndex);
479
480 m_CurrentValues = p_total;
481 }
482
483 void PrepareLayerInfo(int layer, float value, int operator)
484 {
485 m_LayerInfo.Set(layer,{value,operator});
486 AddPriorityInfo(layer);
487 }
488
490 override void SetParameterValueDefault(inout Param p_total)
491 {
492 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
493 m_CurrentValues = p_total;
494 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
495 }
496}
497
498class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
499{
500 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
501 {
502 m_Dependencies = new map<int,ref array<int>>;
503 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
504 }
505}

◆ PPEMatClassParameterFloat()

void PPEMatClassParameterFloat ( int mat_idx,
int parameter_idx,
PPEClassBase parent )
protected
253{
254 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
255
256 protected PPETemplateDefFloat m_Float;
257 protected float m_ValueDefault;
258 protected float m_ValueMin;
259 protected float m_ValueMax;
260
261 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
262 {
263 m_LayerInfo = new map<int,ref array<float,int>>;
264 }
265
266 override void InitDefaults()
267 {
268 Class.CastTo(m_Float,m_Defaults);
269 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
270 m_ValueDefault = m_Float.param2;
271 m_ValueMin = m_Float.param3;
272 m_ValueMax = m_Float.param4;
273 }
274
275 override void InitCuttent()
276 {
277 m_CurrentValues = new Param1<float>(m_ValueDefault);
278 }
279
280 override int GetParameterVarType()
281 {
282 return PPEConstants.VAR_TYPE_FLOAT;
283 }
284
285 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
286 {
287 super.Update(timeslice,p_total,setting_defaults,order);
288
289 int active_request_count = 0;
290
291 PPERequestParamDataFloat req_data;
292
293 bool setting_value_zero = false;
294
295 float float_value_temp = 0.0;
296 float float_value_default = 0.0;
297 float float_value_total = 0.0;
298
299 if (p_total == null)
300 {
301 p_total = new Param1<float>(0.0);
302 }
303
304 if (m_RequestMap.Count() > 0)
305 {
306 m_LayerInfo.Clear();
307 }
308 else
309 {
310 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
311 SetParameterValueDefault(p_total);
312 m_Parent.ParamUpdateRemove(m_ParameterIndex);
313 return;
314 }
315
316 for ( int i = 0; i < m_RequestMap.Count(); i++ )
317 {
318 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
319
320 if (req_data == null)
321 {
322 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
323 continue;
324 }
325
326 setting_value_zero = req_data.IsSettingDefaultValues();
327
328 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
329 {
330 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
331 continue;
332 }
333
334 if (setting_value_zero)
335 {
336 req_data.m_FloatTarget = 0;//min;
337 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
338 }
339 else
340 {
341 active_request_count++;
342 }
343
344 //evaluation
345 //--------------------------------
346 req_data.m_FloatLast = req_data.m_FloatCurrent;
347
348 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
349 {
350 float_value_temp = req_data.m_FloatCurrent;
351 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
352 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
353 continue;
354 }
355
356 float_value_temp = req_data.m_FloatTarget;
357
358 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
359 req_data.SetUpdatingDataValues(false);
360 if (setting_value_zero)
361 {
362 req_data.SetDataActive(false);
363 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
364 }
365 else
366 {
367 float_value_temp = req_data.m_FloatTarget;
368 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
369 }
370
371 req_data.m_FloatCurrent = float_value_temp;
372 }
373
374 //---------------------------
375 //MASK handling and calculation
376 float value;
377 int operator;
378 bool override_active = false;
379
380 if ( m_ValueMax == 0.0 )
381 float_value_total = m_ValueDefault; //?
382 else
383 float_value_total = m_ValueDefault / m_ValueMax;
384
385 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
386 float_value_default = float_value_total;
387
388 for ( i = 0; i < m_LayerInfo.Count(); i++ )
389 {
390 if ( override_active )
391 break;
392
393 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
394 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
395
396 switch (operator)
397 {
398 case PPOperators.LOWEST:
399 float_value_total = Math.Min(float_value_total,value);
400 break;
401
402 case PPOperators.HIGHEST:
403 float_value_total = Math.Max(float_value_total,value);
404 break;
405
406 case PPOperators.ADD:
407 //float_value_total = float_value_total + value - float_value_default;
408 float_value_total = float_value_total + value;
409 break;
410
411 case PPOperators.ADD_RELATIVE:
412 float_value_total = (1 - float_value_total) * value + float_value_total;
413 break;
414
415 case PPOperators.SUBSTRACT:
416 //float_value_total = float_value_total - value + float_value_default;
417 float_value_total = float_value_total - value;
418 break;
419
420 case PPOperators.SUBSTRACT_RELATIVE:
421 float_value_total = float_value_total - value * float_value_total;
422 break;
423
424 case PPOperators.SUBSTRACT_REVERSE:
425 //float_value_total = value - float_value_default - float_value_total;
426 float_value_total = value - float_value_total;
427 break;
428
429 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
430 float_value_total = value * float_value_total - float_value_total;
431 break;
432
433 case PPOperators.MULTIPLICATIVE:
434 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
435 float_value_total = float_value_total * value;
436 break;
437
438 case PPOperators.OVERRIDE:
439 float_value_total = value;
440 break;
441
442 case PPOperators.SET:
443 float_value_total = value;
444 break;
445 }
446
447 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
448 float_value_total = Math.Clamp(float_value_total,0,1);
449
450 if ( operator == PPOperators.OVERRIDE )
451 {
452 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
453 override_active = true;
454 }
455
456 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
457 }
458
459 m_CommandLayersArray.Clear();
460
461 //TODO - consider moving this up, if possible
462 if (active_request_count == 0)
463 {
464 SetParameterValueDefault(p_total);
465 }
466 else
467 {
468 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
469 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
470 }
471
472 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
473 m_Parent.ParamUpdateRemove(m_ParameterIndex);
474
475 m_CurrentValues = p_total;
476 }
477
478 void PrepareLayerInfo(int layer, float value, int operator)
479 {
480 m_LayerInfo.Set(layer,{value,operator});
481 AddPriorityInfo(layer);
482 }
483
485 override void SetParameterValueDefault(inout Param p_total)
486 {
487 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
488 m_CurrentValues = p_total;
489 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
490 }
491}
492
493class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
494{
495 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
496 {
497 m_Dependencies = new map<int,ref array<int>>;
498 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
499 }
500}

Используется в PPEClassBase::RegisterParameterScalarFloat() и PPEClassBase::RegisterParameterScalarFloatEx().

◆ PPEMatClassParameterFloatSaturation()

class PPEMatClassParameterFloat extends PPEMatClassParameterCommandData PPEMatClassParameterFloatSaturation ( int mat_idx,
int parameter_idx,
PPEClassBase parent )
245 {
246 m_Dependencies = new map<int,ref array<int>>;
247 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
248 }

Используется в PPEColors::RegisterMaterialParameters() и PPEGlow::RegisterMaterialParameters().

◆ PrepareLayerInfo()

void PrepareLayerInfo ( int layer,
float value,
int operator )
protected
470{
471 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
472
473 protected PPETemplateDefFloat m_Float;
474 protected float m_ValueDefault;
475 protected float m_ValueMin;
476 protected float m_ValueMax;
477
478 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
479 {
480 m_LayerInfo = new map<int,ref array<float,int>>;
481 }
482
483 override void InitDefaults()
484 {
485 Class.CastTo(m_Float,m_Defaults);
486 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
487 m_ValueDefault = m_Float.param2;
488 m_ValueMin = m_Float.param3;
489 m_ValueMax = m_Float.param4;
490 }
491
492 override void InitCuttent()
493 {
494 m_CurrentValues = new Param1<float>(m_ValueDefault);
495 }
496
497 override int GetParameterVarType()
498 {
499 return PPEConstants.VAR_TYPE_FLOAT;
500 }
501
502 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
503 {
504 super.Update(timeslice,p_total,setting_defaults,order);
505
506 int active_request_count = 0;
507
508 PPERequestParamDataFloat req_data;
509
510 bool setting_value_zero = false;
511
512 float float_value_temp = 0.0;
513 float float_value_default = 0.0;
514 float float_value_total = 0.0;
515
516 if (p_total == null)
517 {
518 p_total = new Param1<float>(0.0);
519 }
520
521 if (m_RequestMap.Count() > 0)
522 {
523 m_LayerInfo.Clear();
524 }
525 else
526 {
527 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
528 SetParameterValueDefault(p_total);
529 m_Parent.ParamUpdateRemove(m_ParameterIndex);
530 return;
531 }
532
533 for ( int i = 0; i < m_RequestMap.Count(); i++ )
534 {
535 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
536
537 if (req_data == null)
538 {
539 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
540 continue;
541 }
542
543 setting_value_zero = req_data.IsSettingDefaultValues();
544
545 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
546 {
547 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
548 continue;
549 }
550
551 if (setting_value_zero)
552 {
553 req_data.m_FloatTarget = 0;//min;
554 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
555 }
556 else
557 {
558 active_request_count++;
559 }
560
561 //evaluation
562 //--------------------------------
563 req_data.m_FloatLast = req_data.m_FloatCurrent;
564
565 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
566 {
567 float_value_temp = req_data.m_FloatCurrent;
568 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
569 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
570 continue;
571 }
572
573 float_value_temp = req_data.m_FloatTarget;
574
575 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
576 req_data.SetUpdatingDataValues(false);
577 if (setting_value_zero)
578 {
579 req_data.SetDataActive(false);
580 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
581 }
582 else
583 {
584 float_value_temp = req_data.m_FloatTarget;
585 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
586 }
587
588 req_data.m_FloatCurrent = float_value_temp;
589 }
590
591 //---------------------------
592 //MASK handling and calculation
593 float value;
594 int operator;
595 bool override_active = false;
596
597 if ( m_ValueMax == 0.0 )
598 float_value_total = m_ValueDefault; //?
599 else
600 float_value_total = m_ValueDefault / m_ValueMax;
601
602 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
603 float_value_default = float_value_total;
604
605 for ( i = 0; i < m_LayerInfo.Count(); i++ )
606 {
607 if ( override_active )
608 break;
609
610 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
611 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
612
613 switch (operator)
614 {
615 case PPOperators.LOWEST:
616 float_value_total = Math.Min(float_value_total,value);
617 break;
618
619 case PPOperators.HIGHEST:
620 float_value_total = Math.Max(float_value_total,value);
621 break;
622
623 case PPOperators.ADD:
624 //float_value_total = float_value_total + value - float_value_default;
625 float_value_total = float_value_total + value;
626 break;
627
628 case PPOperators.ADD_RELATIVE:
629 float_value_total = (1 - float_value_total) * value + float_value_total;
630 break;
631
632 case PPOperators.SUBSTRACT:
633 //float_value_total = float_value_total - value + float_value_default;
634 float_value_total = float_value_total - value;
635 break;
636
637 case PPOperators.SUBSTRACT_RELATIVE:
638 float_value_total = float_value_total - value * float_value_total;
639 break;
640
641 case PPOperators.SUBSTRACT_REVERSE:
642 //float_value_total = value - float_value_default - float_value_total;
643 float_value_total = value - float_value_total;
644 break;
645
646 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
647 float_value_total = value * float_value_total - float_value_total;
648 break;
649
650 case PPOperators.MULTIPLICATIVE:
651 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
652 float_value_total = float_value_total * value;
653 break;
654
655 case PPOperators.OVERRIDE:
656 float_value_total = value;
657 break;
658
659 case PPOperators.SET:
660 float_value_total = value;
661 break;
662 }
663
664 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
665 float_value_total = Math.Clamp(float_value_total,0,1);
666
667 if ( operator == PPOperators.OVERRIDE )
668 {
669 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
670 override_active = true;
671 }
672
673 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
674 }
675
676 m_CommandLayersArray.Clear();
677
678 //TODO - consider moving this up, if possible
679 if (active_request_count == 0)
680 {
681 SetParameterValueDefault(p_total);
682 }
683 else
684 {
685 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
686 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
687 }
688
689 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
690 m_Parent.ParamUpdateRemove(m_ParameterIndex);
691
692 m_CurrentValues = p_total;
693 }
694
695 void PrepareLayerInfo(int layer, float value, int operator)
696 {
697 m_LayerInfo.Set(layer,{value,operator});
698 AddPriorityInfo(layer);
699 }
700
702 override void SetParameterValueDefault(inout Param p_total)
703 {
704 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
705 m_CurrentValues = p_total;
706 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
707 }
708}
709
710class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
711{
712 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
713 {
714 m_Dependencies = new map<int,ref array<int>>;
715 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
716 }
717}

◆ SetParameterValueDefault()

override void SetParameterValueDefault ( inout Param p_total)
protected

No active requests for the mat. parameter value change, sets the value to DEFAULT (zero?)

477{
478 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
479
480 protected PPETemplateDefFloat m_Float;
481 protected float m_ValueDefault;
482 protected float m_ValueMin;
483 protected float m_ValueMax;
484
485 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
486 {
487 m_LayerInfo = new map<int,ref array<float,int>>;
488 }
489
490 override void InitDefaults()
491 {
492 Class.CastTo(m_Float,m_Defaults);
493 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
494 m_ValueDefault = m_Float.param2;
495 m_ValueMin = m_Float.param3;
496 m_ValueMax = m_Float.param4;
497 }
498
499 override void InitCuttent()
500 {
501 m_CurrentValues = new Param1<float>(m_ValueDefault);
502 }
503
504 override int GetParameterVarType()
505 {
506 return PPEConstants.VAR_TYPE_FLOAT;
507 }
508
509 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
510 {
511 super.Update(timeslice,p_total,setting_defaults,order);
512
513 int active_request_count = 0;
514
515 PPERequestParamDataFloat req_data;
516
517 bool setting_value_zero = false;
518
519 float float_value_temp = 0.0;
520 float float_value_default = 0.0;
521 float float_value_total = 0.0;
522
523 if (p_total == null)
524 {
525 p_total = new Param1<float>(0.0);
526 }
527
528 if (m_RequestMap.Count() > 0)
529 {
530 m_LayerInfo.Clear();
531 }
532 else
533 {
534 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
535 SetParameterValueDefault(p_total);
536 m_Parent.ParamUpdateRemove(m_ParameterIndex);
537 return;
538 }
539
540 for ( int i = 0; i < m_RequestMap.Count(); i++ )
541 {
542 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
543
544 if (req_data == null)
545 {
546 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
547 continue;
548 }
549
550 setting_value_zero = req_data.IsSettingDefaultValues();
551
552 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
553 {
554 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
555 continue;
556 }
557
558 if (setting_value_zero)
559 {
560 req_data.m_FloatTarget = 0;//min;
561 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
562 }
563 else
564 {
565 active_request_count++;
566 }
567
568 //evaluation
569 //--------------------------------
570 req_data.m_FloatLast = req_data.m_FloatCurrent;
571
572 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
573 {
574 float_value_temp = req_data.m_FloatCurrent;
575 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
576 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
577 continue;
578 }
579
580 float_value_temp = req_data.m_FloatTarget;
581
582 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
583 req_data.SetUpdatingDataValues(false);
584 if (setting_value_zero)
585 {
586 req_data.SetDataActive(false);
587 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
588 }
589 else
590 {
591 float_value_temp = req_data.m_FloatTarget;
592 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
593 }
594
595 req_data.m_FloatCurrent = float_value_temp;
596 }
597
598 //---------------------------
599 //MASK handling and calculation
600 float value;
601 int operator;
602 bool override_active = false;
603
604 if ( m_ValueMax == 0.0 )
605 float_value_total = m_ValueDefault; //?
606 else
607 float_value_total = m_ValueDefault / m_ValueMax;
608
609 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
610 float_value_default = float_value_total;
611
612 for ( i = 0; i < m_LayerInfo.Count(); i++ )
613 {
614 if ( override_active )
615 break;
616
617 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
618 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
619
620 switch (operator)
621 {
622 case PPOperators.LOWEST:
623 float_value_total = Math.Min(float_value_total,value);
624 break;
625
626 case PPOperators.HIGHEST:
627 float_value_total = Math.Max(float_value_total,value);
628 break;
629
630 case PPOperators.ADD:
631 //float_value_total = float_value_total + value - float_value_default;
632 float_value_total = float_value_total + value;
633 break;
634
635 case PPOperators.ADD_RELATIVE:
636 float_value_total = (1 - float_value_total) * value + float_value_total;
637 break;
638
639 case PPOperators.SUBSTRACT:
640 //float_value_total = float_value_total - value + float_value_default;
641 float_value_total = float_value_total - value;
642 break;
643
644 case PPOperators.SUBSTRACT_RELATIVE:
645 float_value_total = float_value_total - value * float_value_total;
646 break;
647
648 case PPOperators.SUBSTRACT_REVERSE:
649 //float_value_total = value - float_value_default - float_value_total;
650 float_value_total = value - float_value_total;
651 break;
652
653 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
654 float_value_total = value * float_value_total - float_value_total;
655 break;
656
657 case PPOperators.MULTIPLICATIVE:
658 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
659 float_value_total = float_value_total * value;
660 break;
661
662 case PPOperators.OVERRIDE:
663 float_value_total = value;
664 break;
665
666 case PPOperators.SET:
667 float_value_total = value;
668 break;
669 }
670
671 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
672 float_value_total = Math.Clamp(float_value_total,0,1);
673
674 if ( operator == PPOperators.OVERRIDE )
675 {
676 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
677 override_active = true;
678 }
679
680 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
681 }
682
683 m_CommandLayersArray.Clear();
684
685 //TODO - consider moving this up, if possible
686 if (active_request_count == 0)
687 {
688 SetParameterValueDefault(p_total);
689 }
690 else
691 {
692 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
693 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
694 }
695
696 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
697 m_Parent.ParamUpdateRemove(m_ParameterIndex);
698
699 m_CurrentValues = p_total;
700 }
701
702 void PrepareLayerInfo(int layer, float value, int operator)
703 {
704 m_LayerInfo.Set(layer,{value,operator});
705 AddPriorityInfo(layer);
706 }
707
709 override void SetParameterValueDefault(inout Param p_total)
710 {
711 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
712 m_CurrentValues = p_total;
713 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
714 }
715}
716
717class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
718{
719 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
720 {
721 m_Dependencies = new map<int,ref array<int>>;
722 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
723 }
724}

◆ Update()

override void Update ( float timeslice,
out Param p_total,
out bool setting_defaults,
int order )
protected
277{
278 protected ref map<int,ref array<float,int>> m_LayerInfo; //<priority,<value,operator>>
279
280 protected PPETemplateDefFloat m_Float;
281 protected float m_ValueDefault;
282 protected float m_ValueMin;
283 protected float m_ValueMax;
284
285 void PPEMatClassParameterFloat(int mat_idx, int parameter_idx, PPEClassBase parent)
286 {
287 m_LayerInfo = new map<int,ref array<float,int>>;
288 }
289
290 override void InitDefaults()
291 {
292 Class.CastTo(m_Float,m_Defaults);
293 //m_Float = PPETemplateDefFloat.Cast(m_Defaults);
294 m_ValueDefault = m_Float.param2;
295 m_ValueMin = m_Float.param3;
296 m_ValueMax = m_Float.param4;
297 }
298
299 override void InitCuttent()
300 {
301 m_CurrentValues = new Param1<float>(m_ValueDefault);
302 }
303
304 override int GetParameterVarType()
305 {
306 return PPEConstants.VAR_TYPE_FLOAT;
307 }
308
309 override void Update(float timeslice, out Param p_total, out bool setting_defaults, int order)
310 {
311 super.Update(timeslice,p_total,setting_defaults,order);
312
313 int active_request_count = 0;
314
315 PPERequestParamDataFloat req_data;
316
317 bool setting_value_zero = false;
318
319 float float_value_temp = 0.0;
320 float float_value_default = 0.0;
321 float float_value_total = 0.0;
322
323 if (p_total == null)
324 {
325 p_total = new Param1<float>(0.0);
326 }
327
328 if (m_RequestMap.Count() > 0)
329 {
330 m_LayerInfo.Clear();
331 }
332 else
333 {
334 //DbgPrnt("m_RequestMap.Count() is zero! Using default values. | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
335 SetParameterValueDefault(p_total);
336 m_Parent.ParamUpdateRemove(m_ParameterIndex);
337 return;
338 }
339
340 for ( int i = 0; i < m_RequestMap.Count(); i++ )
341 {
342 req_data = PPERequestParamDataFloat.Cast(m_RequestMap.GetElement(i));
343
344 if (req_data == null)
345 {
346 Error("Debug | PPEMatClassParameterFloat | req_data not found! | " + this + " | mat/par: " + m_MaterialIndex + "/" + m_ParameterIndex);
347 continue;
348 }
349
350 setting_value_zero = req_data.IsSettingDefaultValues();
351
352 if (setting_value_zero && !req_data.GetUpdatingDataValues() && !req_data.IsDataActive())
353 {
354 //DbgPrnt("Is Default, not updating | idx: " + i + " | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
355 continue;
356 }
357
358 if (setting_value_zero)
359 {
360 req_data.m_FloatTarget = 0;//min;
361 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !data.m_DefaultTargetSet | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | req_data.m_FloatTarget: " + req_data.m_FloatTarget);
362 }
363 else
364 {
365 active_request_count++;
366 }
367
368 //evaluation
369 //--------------------------------
370 req_data.m_FloatLast = req_data.m_FloatCurrent;
371
372 if (!req_data.GetUpdatingDataValues() && req_data.IsDataActive()) //set to exact value, not updating anymore
373 {
374 float_value_temp = req_data.m_FloatCurrent;
375 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
376 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | !req_data.m_UpdatingData | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | not updating, addaing current value into mix: " + float_value_temp);
377 continue;
378 }
379
380 float_value_temp = req_data.m_FloatTarget;
381
382 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX());
383 req_data.SetUpdatingDataValues(false);
384 if (setting_value_zero)
385 {
386 req_data.SetDataActive(false);
387 //RemovePriorityInfo(req_data.GetPriorityLayer()); //redundant?
388 }
389 else
390 {
391 float_value_temp = req_data.m_FloatTarget;
392 PrepareLayerInfo(req_data.GetPriorityLayer(),float_value_temp,req_data.GetInteractionMask());
393 }
394
395 req_data.m_FloatCurrent = float_value_temp;
396 }
397
398 //---------------------------
399 //MASK handling and calculation
400 float value;
401 int operator;
402 bool override_active = false;
403
404 if ( m_ValueMax == 0.0 )
405 float_value_total = m_ValueDefault; //?
406 else
407 float_value_total = m_ValueDefault / m_ValueMax;
408
409 //float_value_total = Math.InverseLerp(m_ValueMin,m_ValueMax,m_ValueDefault);
410 float_value_default = float_value_total;
411
412 for ( i = 0; i < m_LayerInfo.Count(); i++ )
413 {
414 if ( override_active )
415 break;
416
417 value = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_VALUE);
418 operator = m_LayerInfo.Get(m_CommandLayersArray.Get(i)).Get(LAYER_INFO_OPERATOR);
419
420 switch (operator)
421 {
422 case PPOperators.LOWEST:
423 float_value_total = Math.Min(float_value_total,value);
424 break;
425
426 case PPOperators.HIGHEST:
427 float_value_total = Math.Max(float_value_total,value);
428 break;
429
430 case PPOperators.ADD:
431 //float_value_total = float_value_total + value - float_value_default;
432 float_value_total = float_value_total + value;
433 break;
434
435 case PPOperators.ADD_RELATIVE:
436 float_value_total = (1 - float_value_total) * value + float_value_total;
437 break;
438
439 case PPOperators.SUBSTRACT:
440 //float_value_total = float_value_total - value + float_value_default;
441 float_value_total = float_value_total - value;
442 break;
443
444 case PPOperators.SUBSTRACT_RELATIVE:
445 float_value_total = float_value_total - value * float_value_total;
446 break;
447
448 case PPOperators.SUBSTRACT_REVERSE:
449 //float_value_total = value - float_value_default - float_value_total;
450 float_value_total = value - float_value_total;
451 break;
452
453 case PPOperators.SUBSTRACT_REVERSE_RELATIVE:
454 float_value_total = value * float_value_total - float_value_total;
455 break;
456
457 case PPOperators.MULTIPLICATIVE:
458 //float_value_total = Math.Lerp(float_value_default, float_value_total, value);
459 float_value_total = float_value_total * value;
460 break;
461
462 case PPOperators.OVERRIDE:
463 float_value_total = value;
464 break;
465
466 case PPOperators.SET:
467 float_value_total = value;
468 break;
469 }
470
471 //DbgPrnt("m_LayerInfo | float_value_total pre-clamp: " + float_value_total + " | i: " + i);
472 float_value_total = Math.Clamp(float_value_total,0,1);
473
474 if ( operator == PPOperators.OVERRIDE )
475 {
476 //DbgPrnt("m_LayerInfo | PPOperators.OVERRIDE at: " + i);
477 override_active = true;
478 }
479
480 //RemovePriorityInfo(m_CommandLayersArray.Get(i));
481 }
482
483 m_CommandLayersArray.Clear();
484
485 //TODO - consider moving this up, if possible
486 if (active_request_count == 0)
487 {
488 SetParameterValueDefault(p_total);
489 }
490 else
491 {
492 float res = Math.Lerp(m_ValueMin,m_ValueMax,float_value_total);
493 Param1<float>.Cast(p_total).param1 = res; //converts back to absolute values
494 }
495
496 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | mat/par/req: " + m_MaterialIndex + "/" + m_ParameterIndex + "/" + req_data.GetRequesterIDX() + " | parameter update end, removing from queue");
497 m_Parent.ParamUpdateRemove(m_ParameterIndex);
498
499 m_CurrentValues = p_total;
500 }
501
502 void PrepareLayerInfo(int layer, float value, int operator)
503 {
504 m_LayerInfo.Set(layer,{value,operator});
505 AddPriorityInfo(layer);
506 }
507
509 override void SetParameterValueDefault(inout Param p_total)
510 {
511 p_total = new Param1<float>(PPETemplateDefFloat.Cast(m_Defaults).param2);
512 m_CurrentValues = p_total;
513 //DbgPrnt("PPEDebug | PPEMatClassParameterFloat - UpdateParameterValues | exit 3 - zero value");
514 }
515}
516
517class PPEMatClassParameterFloatSaturation extends PPEMatClassParameterFloat
518{
519 void PPEMatClassParameterFloatSaturation(int mat_idx, int parameter_idx, PPEClassBase parent)
520 {
521 m_Dependencies = new map<int,ref array<int>>;
522 m_Dependencies.Set(PostProcessEffectType.Glow,{PPEGlow.PARAM_COLORIZATIONCOLOR, PPEGlow.PARAM_OVERLAYCOLOR});
523 }
524}

Переменные

◆ m_Float

PPETemplateDefFloat m_Float
protected

Используется в PPEMatClassParameterCommandData::InitDefaults().

◆ m_LayerInfo

ref map<int,ref array<float,int> > m_LayerInfo
protected

◆ m_ValueDefault

float m_ValueDefault
protected

Используется в PPEMatClassParameterCommandData::InitCuttent(), PPEMatClassParameterCommandData::InitDefaults() и PPEMatClassParameterCommandData::Update().

◆ m_ValueMax

float m_ValueMax
protected

Используется в PPEMatClassParameterCommandData::InitDefaults() и PPEMatClassParameterCommandData::Update().

◆ m_ValueMin

float m_ValueMin
protected

Используется в PPEMatClassParameterCommandData::InitDefaults() и PPEMatClassParameterCommandData::Update().