/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2012 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

-----------------------------------------------------------------------------
*/
  
struct WaterTransitionStr = [
                  PST_timeSpeed    		    : F,
                  PST_cWaveStrenght 	    : [F F F], //src dst time
                  PST_cWaveChoppyStrenght : [F F F],
                  PST_cWaveScale  		    : [F F F],
                  PST_cLevel    		      : [F F F],
                  PST_cDepth      		    : [F F F],
                  PST_cWaterColor         : [F F F F F F F F F]
                  
                ] MkWaterTransitionStr;;

fun deleteOb(inst)=
  setPluginInstanceCbScenePreRender inst nil;
  0;;


fun cbScenePreRender(inst, sessionstr, etime, obstr)=
  if (obstr.PST_timeSpeed <=. 0.0) then nil else
  let c3dXsession -> sessionstr in
  let if etime == 0 then 1 else etime -> etime in
  let (itof etime) /. 1000000.0 -> ftime in
  let nil -> wstrenght in
  let nil -> cstrenght in
  (
    if (obstr.PST_cWaveStrenght == nil) then nil else
    let obstr.PST_cWaveStrenght -> [src dst tm] in
    let tm +. ftime -> ntm in
    let (((dst -. src) /. obstr.PST_timeSpeed) *. ntm) -> nval in
    (
      set wstrenght = if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then dst else src +. nval;
      if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then
      (
        set obstr.PST_cWaveStrenght = nil;
        0;
      )
      else
      (
        mutate obstr.PST_cWaveStrenght <- [_ _ ntm];
        0;
      );
    );
    
    if (obstr.PST_cWaveChoppyStrenght == nil) then nil else
    let obstr.PST_cWaveChoppyStrenght -> [src dst tm] in
    let tm +. ftime -> ntm in
    let (((dst -. src) /. obstr.PST_timeSpeed) *. ntm) -> nval in
    (
      set cstrenght = if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then dst else src +. nval;
      if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then
      (
        set obstr.PST_cWaveChoppyStrenght = nil;
        0;
      )
      else
      (
        mutate obstr.PST_cWaveChoppyStrenght <- [_ _ ntm];
        0;
      );
    );
    
    if (wstrenght == nil && cstrenght == nil) then nil else
      SO3WaterSetWaveParameters (V3DgetSession sessionstr) wstrenght nil cstrenght;
    
    if (obstr.PST_cWaveScale == nil) then nil else
    let obstr.PST_cWaveScale -> [src dst tm] in
    let tm +. ftime -> ntm in
    let (((dst -. src) /. obstr.PST_timeSpeed) *. ntm) -> nval in
    (
      if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then
      (
        SO3WaterSetPerlinNoiseParameters (V3DgetSession sessionstr) dst nil nil nil nil nil nil;
        SO3WaterSetCausticsParameters (V3DgetSession sessionstr) 100.0 /. (if dst >. 0.0 then dst else 1.0) nil nil;
        set obstr.PST_cWaveScale = nil;
        0;
      )
      else
      (
        let src +. nval -> value in
        (
          SO3WaterSetPerlinNoiseParameters (V3DgetSession sessionstr) value nil nil nil nil nil nil;
          SO3WaterSetCausticsParameters (V3DgetSession sessionstr) 100.0 /. (if value >. 0.0 then value else 1.0) nil nil;
        );
        mutate obstr.PST_cWaveScale <- [_ _ ntm];
        0;
      );
    );

    if (obstr.PST_cLevel == nil) then nil else
    let obstr.PST_cLevel -> [src dst tm] in
    let tm +. ftime -> ntm in
    let (((dst -. src) /. obstr.PST_timeSpeed) *. ntm) -> nval in
    (
      if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then
      (
        SO3WaterSetPosition (V3DgetSession sessionstr) [0.0 dst 0.0];
        set obstr.PST_cLevel = nil;
        0;
      )
      else
      (
        SO3WaterSetPosition (V3DgetSession sessionstr) [0.0 (src +. nval) 0.0];
        mutate obstr.PST_cLevel <- [_ _ ntm];
        0;
      );
    );
    
    if (obstr.PST_cDepth == nil) then nil else
    let obstr.PST_cDepth -> [src dst tm] in
    let tm +. ftime -> ntm in
    let (((dst -. src) /. obstr.PST_timeSpeed) *. ntm) -> nval in
    (
      if (ntm >=. obstr.PST_timeSpeed) || ((src +. nval) == dst) then
      (
        SO3WaterSetDepthParameters (V3DgetSession sessionstr) dst dst;
        set obstr.PST_cDepth = nil;
        0;
      )
      else
      (
        SO3WaterSetDepthParameters (V3DgetSession sessionstr) (src +. nval) (src +. nval);
        mutate obstr.PST_cDepth <- [_ _ ntm];
        0;
      );
    );
    
    if (obstr.PST_cWaterColor == nil) then nil else
    let obstr.PST_cWaterColor -> [sr sg sb dr dg db tmr tmg tmb] in
    let tmr +. ftime -> ntmr in
    let tmg +. ftime -> ntmg in
    let tmb +. ftime -> ntmb in
    let (((dr -. sr) /. obstr.PST_timeSpeed) *. ntmr) -> nvalr in
    let (((dg -. sg) /. obstr.PST_timeSpeed) *. ntmg) -> nvalg in
    let (((db -. sb) /. obstr.PST_timeSpeed) *. ntmb) -> nvalb in
    let if (ntmr >=. obstr.PST_timeSpeed) || ((sr +. nvalr) == dr) then (ftoi dr) else (ftoi (sr +. nvalr)) -> nr in
    let if (ntmg >=. obstr.PST_timeSpeed) || ((sg +. nvalg) == dg) then (ftoi dg) else (ftoi (sg +. nvalg)) -> ng in
    let if (ntmb >=. obstr.PST_timeSpeed) || ((sb +. nvalb) == db) then (ftoi db) else (ftoi (sb +. nvalb)) -> nb in
    (
      SO3WaterSetColor (V3DgetSession sessionstr) G2Drgb2rgba make_rgb nr ng nb 0;
      if ((nr == (ftoi dr)) && (ng == (ftoi dg)) && (nb == (ftoi db))) then
        set obstr.PST_cWaterColor = nil
      else
        mutate obstr.PST_cWaterColor <- [_ _ _ _ _ _ ntmr ntmg ntmb];
    );
  );
  0;;


fun enableWater(state)=
  let c3dXsession -> sessionstr in
  if (state) then
  (
    SO3WaterSetEnable (V3DgetSession sessionstr) 1;
  )
  else
  (
    SO3WaterSetEnable (V3DgetSession sessionstr) 0;
  );
  0;;


fun cbEnable(inst, from, action, param, rep, obstr)=
  enableWater 1;
  0;;
  

fun cbDisable(inst, from, action, param, rep, obstr)=
  enableWater 0;
  0;;


fun cbSetUnderWater(inst, from, action, param, rep, obstr)=
  let atoi param -> state in
  let c3dXsession -> sessionstr in
    SO3WaterComponentSetEnabled (V3DgetSession sessionstr) SO3_WATER_COMPONENT_UNDERWATER state;
  0;;


fun cbSetFoam(inst, from, action, param, rep, obstr)=
  let atoi param -> state in
  let c3dXsession -> sessionstr in
    SO3WaterComponentSetEnabled (V3DgetSession sessionstr) SO3_WATER_COMPONENT_FOAM state;
  0;;


fun cbSetCaustics(inst, from, action, param, rep, obstr)=
  let atoi param -> state in
  let c3dXsession -> sessionstr in
    SO3WaterComponentSetEnabled (V3DgetSession sessionstr) SO3_WATER_COMPONENT_CAUSTICS state;
  0;;


fun cbSetWaveStrenght(inst, from, action, param, rep, obstr)=
  let atof param -> value in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetWaveParameters (V3DgetSession sessionstr) value nil nil;
    0;
  )
  else
  (
    let SO3WaterGetWaveParameters (V3DgetSession sessionstr) -> [strenght elevation choppy] in
    (
      set obstr.PST_cWaveStrenght = [strenght value 0.0];
    );
    0;
  );    
  0;;


fun cbSetWaveChoppyStrenght(inst, from, action, param, rep, obstr)=
  let atof param -> value in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetWaveParameters (V3DgetSession sessionstr) nil nil value;
    0;
  )
  else
  (
    let SO3WaterGetWaveParameters (V3DgetSession sessionstr) -> [strenght elevation choppy] in
    (
      set obstr.PST_cWaveChoppyStrenght = [choppy value 0.0];
    );
    0;
  );
  0;;


fun cbSetWaveScale(inst, from, action, param, rep, obstr)=
  let atof param -> value in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetPerlinNoiseParameters (V3DgetSession sessionstr) value nil nil nil nil nil nil;
    SO3WaterSetCausticsParameters (V3DgetSession sessionstr) 100.0 /. (if value >. 0.0 then value else 1.0) nil nil;
    0;
  )
  else
  (
    let SO3WaterGetPerlinNoiseParameters (V3DgetSession sessionstr) -> [scale _ _ _ _ _ _] in
    (
      set obstr.PST_cWaveScale = [scale value 0.0];
    );
    0;
  );  
  0;;


fun cbSetWaveComplexity(inst, from, action, param, rep, obstr)=
  let atoi param -> value in
  let c3dXsession -> sessionstr in
    SO3WaterSetGeometryComplexity (V3DgetSession sessionstr) value;
  0;;


fun cbSetLevel(inst, from, action, param, rep, obstr)=
  let atof param -> value in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetPosition (V3DgetSession sessionstr) [0.0 value 0.0];
    0;
  )
  else
  (
    let SO3WaterGetPosition (V3DgetSession sessionstr) -> [_ level _] in
    (
      set obstr.PST_cLevel = [level value 0.0];
    );
    0;
  );
  0;;


fun cbSetDepth(inst, from, action, param, rep, obstr)=
  let atof param -> value in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetDepthParameters (V3DgetSession sessionstr) value value;
    0;
  )
  else
  (
    let SO3WaterGetDepthParameters (V3DgetSession sessionstr) -> [_ depth] in
    (
      set obstr.PST_cDepth = [depth value 0.0];
    );
    0;
  );
  0;;


fun cbSetWaveColor(inst, from, action, param, rep, obstr)=
  let
    if (!strcmp "0x" (substr param 0 2)) then
      G2Drgb2rgba G2Drgb2bgr htoi param 0
    else
      let hd strextr param -> lp in
      let atoi hd lp -> r in
      let atoi hd tl lp -> g in
      let atoi hd tl tl lp -> b in
        make_rgba r g b 128
  -> color in
  let c3dXsession -> sessionstr in
  if (obstr.PST_timeSpeed <=. 0.0) then
  (
    SO3WaterSetColor (V3DgetSession sessionstr) color;
    0;
  )
  else
  (
    let get_rgba SO3WaterGetColor (V3DgetSession sessionstr) -> [sr sg sb sa] in
    let get_rgba color -> [dr dg db da] in
      set obstr.PST_cWaterColor = [(itof sr) (itof sg) (itof sb) (itof dr) (itof dg) (itof db) 0.0 0.0 0.0];
    0;
  );
  0;;
  

fun cbSetTransition(inst, from, action, param, rep, obstr)=
  set obstr.PST_timeSpeed = atof param;
  0;;


fun newOb(inst)=
  let c3dXsession -> sessionstr in
  let V3DgetDefaultViewport (V3DgetSessionView sessionstr) -> defaultviewportstr in
  if ((SO3EnvironmentGetEnable (V3DgetSession sessionstr)) == 1) then nil else
  (
    SO3EnvironmentRegisterViewport (V3DgetSession sessionstr) defaultviewportstr.V3D_viewport;
    SO3EnvironmentSetEnable (V3DgetSession sessionstr) 1;
    SO3EnvironmentSetPaused (V3DgetSession sessionstr) 0;
  ); 
  
  let atof (getPluginInstanceParam inst "transitionTime") -> transitionTime in
  let if transitionTime == nil then 1.0 else transitionTime -> transitionTime in
  let MkWaterTransitionStr [transitionTime nil nil nil nil nil nil] -> obstr in
  (
    PluginRegisterAction inst "Enable" mkfun6 @cbEnable obstr;
    PluginRegisterAction inst "Disable" mkfun6 @cbDisable obstr;
    PluginRegisterAction inst "Set render under water" mkfun6 @cbSetUnderWater obstr;
    PluginRegisterAction inst "Set render foam" mkfun6 @cbSetFoam obstr;
    PluginRegisterAction inst "Set render caustics" mkfun6 @cbSetCaustics obstr;
    PluginRegisterAction inst "Set wave strenght" mkfun6 @cbSetWaveStrenght obstr;
    PluginRegisterAction inst "Set choppy strenght" mkfun6 @cbSetWaveChoppyStrenght obstr;
    PluginRegisterAction inst "Set wave scale" mkfun6 @cbSetWaveScale obstr;
    PluginRegisterAction inst "Set complexity" mkfun6 @cbSetWaveComplexity obstr;
    PluginRegisterAction inst "Set level" mkfun6 @cbSetLevel obstr;
    PluginRegisterAction inst "Set depth" mkfun6 @cbSetDepth obstr;
    PluginRegisterAction inst "Set water color" mkfun6 @cbSetWaveColor obstr;
    PluginRegisterAction inst "Set transition time" mkfun6 @cbSetTransition obstr;
    
    setPluginInstanceCbScenePreRender inst mkfun4 @cbScenePreRender obstr;
  );
  
  setPluginInstanceCbDel inst @deleteOb;
  0;;


fun IniPlug(file)=
  PlugRegister @newOb nil;
  setPluginEditor @dynamicedit;
  0;;