Exchange the Parts of the Model

When you want to exchange the parts like arms in the motion, you invoke the normalizePartsOpacityGroup() method for each frame.
*This method is used only for temporary, and may be changed later.

How to use normalizePartsOpacityGroup() is as below;


  1. public void normalizePartsOpacityGroup( Live2DModelAndroid myLive2DModel, String paramGroup[] , float deltaTimeSec )
  2. {
  3.     if ( myLive2DModel == null ) return;
  4.  
  5.     int visibleParts = -1 ;
  6.     float visibleOpacity = 0 ;
  7.  
  8.     float CLEAR_TIME_SEC = 0.5f ;//It becomes opaque at this time
  9.     float phi = 0.5f ;//If you want to slow the pace from 0 to 1 without the effect to the background, make it bigger than 0.5. However it does not seem to be very natural.
  10.     float maxBackOpacity = 0.15f ;
  11.  
  12.  
  13.     //First time
  14.     if( deltaTimeSec == 0 )
  15.     {
  16.         String partsVisibleID , partsID;
  17.         boolean v;
  18.         int index;
  19.         for (int i = 0 ; i < 999 && paramGroup[i] != null; i++ )
  20.         {
  21.             partsVisibleID = paramGroup[i];
  22. //          index = partsVisibleID.indexOf(":");
  23.             partsID = partsVisibleID.substring(8);// Skip "VISIBLE:"
  24.             v = ( myLive2DModel.getParamFloat( partsVisibleID ) != 0 ) ;
  25.             myLive2DModel.setPartsOpacity(partsID , (v ? 1.0f : 0.0f) ) ;
  26.         }
  27.         return ;//End
  28.     }
  29.     else
  30.     {
  31.         String partsVisibleID , partsID;
  32.         // Get the parts which is displayed at the moment
  33.         for (int i = 0 ; i < 999 && paramGroup[i] != null; i++ )
  34.         {
  35.             partsVisibleID = paramGroup[i];
  36.             boolean v = ( myLive2DModel.getParamFloat( partsVisibleID ) != 0 );
  37.  
  38.             if( v )
  39.             {
  40.                 if( visibleParts >= 0 )
  41.                 {
  42.                     break ;
  43.                 }
  44.                 visibleParts = i ;
  45.                 partsID = partsVisibleID.substring(8) ;// Skip "VISIBLE:"
  46.                 visibleOpacity = myLive2DModel.getPartsOpacity(partsID) ;
  47.  
  48.                 // Calculate new Opacity
  49.                 visibleOpacity += deltaTimeSec / CLEAR_TIME_SEC ;
  50.                 if( visibleOpacity > 1 )
  51.                 {
  52.                     visibleOpacity = 1 ;
  53.                 }
  54.             }
  55.         }
  56.  
  57.         if( visibleParts < 0 )
  58.         {
  59.             visibleParts = 1 ;
  60.             visibleOpacity = 1 ;
  61.         }
  62.  
  63.         float opacity ,a1 , backOp ;
  64.         // Set the transparency of displayed parts and hidden parts
  65.         for (int i = 0 ; i < 999 && paramGroup[i] != null ; i++ )
  66.         {
  67.             partsVisibleID = paramGroup[i] ;
  68.             partsID = partsVisibleID.substring(8) ;// Skip "VISIBLE:"
  69.  
  70.             // Set display parts
  71.             if( visibleParts == i )
  72.             {
  73.                 myLive2DModel.setPartsOpacity(partsID , visibleOpacity ) ;//Set first
  74.             }
  75.             // Set hidden parts
  76.             else
  77.             {
  78.                 opacity = myLive2DModel.getPartsOpacity(partsID) ;
  79.                 if( visibleOpacity < phi ){
  80.                     a1 = visibleOpacity*(phi-1)/phi + 1 ; // Linear which goes through (0,1),(phi,phi)
  81.                 }
  82.                 else
  83.                 {
  84.                     a1 = (1-visibleOpacity)*phi/(1-phi) ; // Linear which goes through(1,0),(phi,phi)
  85.                 }
  86.  
  87.                 //When restricting the rate of background to be seem
  88.                 backOp = (1-a1)*(1-visibleOpacity) ;//in the background
  89.                 if( backOp > maxBackOpacity )
  90.                 {
  91.                     a1 = 1 - maxBackOpacity/( 1- visibleOpacity ) ;
  92.                 }
  93.  
  94.                 if( opacity > a1 )
  95.                 {
  96.                     opacity = a1 ;// Raise the transparency if it is higher than the calculated value. 
  97.                 }
  98.             myLive2DModel.setPartsOpacity(partsID , opacity ) ;
  99.         }
  100.     }
  101. }




It is like the following pseudo code in the actual use.

---Class function-------------------------------------------------------------------------
  1. Live2DModel live2DModel;     // ・・・[1]
  2. long lastTime = 0;           // ・・・[2]

[1]: Instantiate the Live2DModel class.
      This is a model to exchange the parts.

[2]: The time which took in the previous drawing.
       This is used to get the time elapsed from the previous drawing.

---When invoked for each drawing-------------------------------------------------------------------------
  1. String ARM_VISIBLE[] = { "VISIBLE:PARTS_01_ARM_01", "VISIBLE:PARTS_01_ARM_02", null };     // ・・・[1]
  2.  
  3. long  curTime        = UtSystem.getTimeMSec()                                            // ・・・[2]
  4. float deltaTimeSec   = ( lastTime == 0 ) ? 0 : ( curTime - lastTime 1000.0f ;      // ・・・[3]
  5. lastTime             = curTime;                                                            // ・・・[4]
  6.  
  7. normalizePartsOpacityGroup( live2DModel, ARM_VISIBLE, deltaTimeSec);                       // ・・・[5]

[1]: Arrange the Part ID which you want to exchange.
      Specify the Part ID which you want to display during initializing for the first, and specify the Part ID which you want to hide during initializing for the second, and specify null for the third.

[2]: Get the present time.

[3]: Calculate the past time from the previous drawing.
      Present time minus the time of the previous drawing

[4]: Save the time which you get in [2].

[5]: Evoke above normalizePartsOpacityGroup().
       


Comments