mode(建模)1.4 从使用者的角度优化1次

  --********************************************************************************
  --****2011.4.25 我现在选择的 边的ring 选择边的loop 还只是停留在对单个的处理。现在我要把它处理成多个的。
  ---多个处理是单个处理的循环,
  --****
  --****
  --**********************************************************************************
--- rollout
global gt_Scatter_tool
/*
 ----这里我判断不用了
global localHit=[0,0,0], localNormal=[0,0,0], worldHit=[0,0,0], worldNormal=[0,0,0] ----原来这里的东西早就不用了
global helperOBJ = undefined
*/
global ScatOBJ = undefined  ---着一点值得我学习。是什么呢, 全局还要给初始值。 在我之前开发的脚本系类中最后的bug 都是因为这了、
global timeS1=timestamp(),  timeS2=timestamp() --主板行走时间
global SCT_TargetOBJ =#() , TobjST

  
struct TargetOBJ  (obj, randomValue=1, rotateV=0, sizeV=100, rotateX=0, rotateY=0, rotateZ=0, MoveV=0, OriginalScale=[1,1,1])
TobjST = TargetOBJ() ---定义结构 这里是为了随时的存入值,可以随时的取出值。


fn OBJsizeFN  obj = (   --如果输入的物体没有被删就求出最大减最小/2 之间的距离。
 if (isdeleted obj) == true do return 0
 ma= obj.max
 mi= obj.min
 
 return ((distance ma mi)/2.) -----这个函数在下面的应用主要说明笔刷的大小。
)

fn helperFN =
(
-- map=mapScreenToCP mouse.pos (getViewSize())
-- point pos:map
                           ---因为这里调用对话况的控件 古全局定义这个数。
 if ScatOBJ == undefined or gt_Scatter_tool.start_btn.state == OFF  do return false ----但我第一次拾取物体时。ScatOBJ 就定义了。
  ---在这个函数中以上两个条件有一个对就返回。 这里开始进行肯定是返回的
 mouseray = mapScreenToWorldRay mouse.pos --这里应该是鼠标屏幕对应的射线
 sectray = intersectRAY ScatOBJ mouseray   -------------------------------------鼠标工具与拾取物体的焦点。
 
  ---求出一个焦点,是这样的。节点是shape 返回undefined 和曲面没有焦点也是没有的。
 if sectray == undefined do return false --没有焦点结束函数              -------------由于时间是不断检查的,所以一旦有就会往下进行。

-- TobjST.randomValue = random 1  SCT_TargetOBJ.count

 if TobjST.obj == undefined  or  (isdeleted TobjST.obj) == true  then ----------------我现在觉得应该会进入这个事件中去。 -----第一次肯定是要进去,因为我们没有指定过,
 --如果结构中的obj没有指定,或者是被删了进行下面的操作,并且是带回车的。
 (
  undo on (
                                          ---其实下面是定义了一个空组。就是开始什么都没有,慢慢的在+ 中加入。
   TobjST.randomValue = random 1  SCT_TargetOBJ.count --结构中的数量等于1 到到列队中的个数。
   
   ---关于random 的用法1 0 是有事时1 有时时零。在这个中因为都是。integer所以返回的必定是整数、
   
 
   TobjST.obj = instance SCT_TargetOBJ[TobjST.randomValue] --定义了obj为赋值关联类表中的某一个。
   
   ------这里定义了结构中的这个节点
   
   
   TobjST.sizeV = random gt_Scatter_tool.MinScale_spi.value  gt_Scatter_tool.MaxScale_spi.value
   --sizeV 默认是100 这里面又要从新定义。这里是缩放函数 在这里重新的读取一下界面中的数。

   TobjST.rotateX = random gt_Scatter_tool.MinRotateX_spi.value  gt_Scatter_tool.MaxRotateX_spi.value
   TobjST.rotateY = random gt_Scatter_tool.MinRotateY_spi.value  gt_Scatter_tool.MaxRotateY_spi.value
   TobjST.rotateZ = random gt_Scatter_tool.MinRotateZ_spi.value  gt_Scatter_tool.MaxRotateZ_spi.value
            ----上面重新定义了旋转的随机函数。   
   
   TobjST.MoveV = random gt_Scatter_tool.MinMove_spi.value  gt_Scatter_tool.MaxMove_spi.value
            ---定义了高低的随机函数
   
   ---这里面定义了画笔的大小,用的是函数是制定物体的半径
   thePainterInterface.maxSize= OBJsizeFN  TobjST.obj

  --- thePainterInterface 是个绘画函数
   
   TobjST.obj.dir = sectray.dir---下面的每一个几何体和鼠标 对应 的射线
   --说的是什么轴向向上。
   
   --物体的射线方向
   TobjST.obj.name = "scatter_Helper" --- 这里 是明明几何体的名字。
   ---应为随着时间的绘画这里是不断的关联复制。
   
   
   in coordsys local TobjST.obj.rotation = (EulerAngles  TobjST.rotateX  TobjST.rotateY (TobjST.rotateV + TobjST.rotateZ) )
   ---在自身的坐标轴下,结构中物体的旋转, 在z轴上加入了一个旋转v 这个很重要。
   ----上面是说明在进行自身的旋转, 在z轴上加入了一些变化 明白了。加入了rotateV也就是说。打上自动旋转后。同时还可以按下shift 进行旋转处理。
   
   
   TobjST.OriginalScale = TobjST.obj.scale --已经有了定义在定义变化。
   --重新定义结构体中的 OriginalScale 的值,
   
   
   TobjST.obj.scale = (TobjST.OriginalScale * (TobjST.sizeV/100.)) ---实现了随机的缩放。
    ---算法。上面的上面是吧obj的上次缩放给 Originalscale  相当于本身 在乘以一个随机的%比。

   TobjST.obj.pos = sectray.pos ---鼠标与几何体的表面
    ---这个是最重要的一部了,就是把物体画到表面的东西
    
   in coordsys local TobjST.obj.pos = [0,0, TobjST.MoveV] ---在这里明白操作 就是不明白解释。
    
   ----明白了终于明白了,这里面说的是,物体的当给了变化值,在自身的方向,z轴在移动一次。相当于先给 了点,在在点上是为原点在移动

  )
 )
 else (
  TobjST.obj.pos = sectray.pos
  in coordsys local TobjST.obj.pos = [0,0, TobjST.MoveV]

  TobjST.obj.dir = sectray.dir
  in coordsys local TobjST.obj.rotation = (EulerAngles  TobjST.rotateX  TobjST.rotateY (TobjST.rotateV + TobjST.rotateZ) )
  TobjST.obj.scale = (TobjST.OriginalScale * (TobjST.sizeV/100.))
 )
 
 setSysCur #uscale

)


fn OBJrotateFN = (
 TobjST.rotateV += gt_Scatter_tool.add_del_.value
)
--------------------------对于绑定的操作我想加入-10 --------------
fn OBJrotateFN__ = (
 TobjST.rotateV -= gt_Scatter_tool.add_del_.value --------在此验证了+ —— 是不加空格的
)

fn  MouseOverObject = ( ---------------------------------------这里应该是鼠标移动事件。
 ga =$geometry as array ---把所有的做pick

-- ga = for i in ga where i.name != "scatter_Helper"  collect i

 delga = finditem ga $scatter_Helper ---在几何体中查找这个物体,
 if  delga != 0 do  deleteitem ga delga  ---如果查找 到了 $scatter_Helper 这个节点  就从数组中删除它。
 
 mouseray = mapScreenToWorldRay mouse.pos ---又做一条射线。
 coOBJ = #();   coRay=#() ---两个备用数组。
 for i in ga do  (
  sectray = intersectRAY i mouseray  --鼠标射线和所有的物体间的交汇处 ------------因为这些函数在时间的节点下实时进行。
  if sectray != undefind  do ( --- 这里面的交汇只能是个几何体 没有交上, 是undefind 
   append  coOBJ   i ---物体加入到
   append  coRay  sectray ----把没有找到物体的射线加入到这个里面。
  )
 )
 if coRay.count == 0 do return false  ---如果鼠标射线和所有物体没有交点 那么这个数组就是0 返回  不在往下进行。鼠标射线不可能所有的
  --物体没有交点,所以用到这里一般有效 我们知道这里是按下ctrl 找被刷物体时的事件。

 vv= (inverse (viewport.getTM())).pos  ---求出相反的矩阵 的pos
 cTemp= distance  vv coRay[1].pos;   cTempI = 1
 
 for i in 1 to coRay.count do (
  if cTemp > (distance  vv coRay[i].pos) do (
   cTemp= (distance  vv coRay[i].pos)
   cTempI = i
  )
 )

 format "%   %\n" coOBJ[cTempI].name   cTemp ----- 这里对于对于距离输出,还是很不好明白。
 return coOBJ[cTempI]
)


fn newOBJcheckFN =(                             -----------------------这个函数在中标中进行对于人的操作速度来说几乎是事实进行的。
 local mState= mouse.buttonStates               ----鼠标按下的状态。
 local mouseState=mState as array --转换成数组。花括号 转小括号。


 if keyboard.shiftPressed == ON and  keyboard.controlPressed == OFF  and  gt_Scatter_tool.start_btn.state  == ON   do (
  TobjST.rotateV= OBJrotateFN() ---旋转递加
  ---这个功能我刚刚用到
 )
 
 if keyboard.shiftPressed == ON and  keyboard.controlPressed == on  and  gt_Scatter_tool.start_btn.state  == ON   do (
  TobjST.rotateV= OBJrotateFN__() ---旋转递加
  ---这个功能我刚刚用到
 )

 
 --- keyboard ctrl  滚瓢捞 喘府搁 促弗坷宏璃飘 急琶
 if keyboard.controlPressed == ON  and  keyboard.shiftPressed == OFF   and  gt_Scatter_tool.start_btn.state  == ON   do (
  MOO = MouseOverObject()
--  print MOO
  if MOO == false do return false  -----这个事件主要是说明给要刷的物体换东西。
  gt_Scatter_tool.obj_btn.picked  MOO
 )
)

fn startStroke = (
 print "start"
)

fn paintStroke = (

-- thePainterInterface.getHitPointData &localHit &localNormal &worldHit &worldNormal 0.5 0.5 0
-- format "%  %  %  %\n" localHit localNormal  worldHit  worldNormal

 if TobjST.obj == undefined do return false
 timeS2=timestamp() ---重新定义取新的时间。
 timeT =  timeS2 - timeS1  ----------------------找出时间差  如果大于100 才创建东西。小于则不见。
 if timeT > gt_Scatter_tool.bugu_bul.value do  (
--  box pos:worldHit dir:worldNormal   --- 其牢飘牢磐其捞胶甫 荤侩且版快俊绰 捞巴阑 荤侩... face 俊 畴富蔼阑 舅酒晨
--  helperOBJPaint =  TobjST.obj
--  helperOBJPaint.pos = worldHit
--  helperOBJPaint.dir = worldNormal
  TobjST.obj.name = uniqueName "scatter_Helper" ---唯一的命名 也是第一个命名 在删除时则总是删除这个。
  timeS1=timestamp()  
  TobjST.obj = undefined
 )

 
)


fn cancelStroke = print "Handle cancel stroke here"
fn endStroke = (
 thePainterInterface.updateMeshes on
-- print "Update"
)


fn initFN_2 = (
-- nodeList = ScatOBJ   --- 盔贰绰 捞巴!!
 nodeList = undefined
 thePainterInterface.initializeNodes 0 nodeList
)

fn initFN = (
 thePainterInterface.endPaintSession()
-- if Dig_tool.obj_btn.object == undefined do return false
--- if (Superclassof Dig_tool.obj_btn.object) != GeometryClass  do return false

---   其牢磐 牢磐其捞胶甫 荤侩窍登 坷宏璃飘甫 固沥狼窍骨肺辑 加档甫 俺急矫糯
-- nodeList = ScatOBJ   --- 盔贰绰 捞巴!!
 nodeList = undefined
 
 
 thePainterInterface.initializeNodes 0 nodeList
 try( thePainterInterface.maxSize= OBJsizeFN  TobjST.obj  )catch() --这里的笔刷算法相当于物体的半径。最大减最小在除2 。
 thePainterInterface.ScriptFunctions startStroke paintStroke endStroke cancelStroke systemEnd
 thePainterInterface.offMeshHitType = 2
 
    thePainterInterface.updateOnMouseUp =false
 thePainterInterface.drawTrace =On
 thePainterInterface.drawNormal = off
 thePainterInterface.drawRing = off
  --thePainterInterface.maxSize=2000
 thePainterInterface.treeDepth = 2
 thePainterInterface.pressureEnable = OFF
 thePainterInterface.pressureAffects = 1
 --thePainterInterface.dragStrLimitMin=100
 --thePainterInterface.dragStrLimitMax=100

 
 thePainterInterface.startPaintSession()----画笔开始
 setSysCur #uscale --鼠标状态
)

try(destroyDialog gt_Scatter_tool)catch()
rollout gt_Scatter_tool "(盖天)繁殖:绑定:.." width:210 height:300
(      
  fn  load_icon  = (
  a=openbitmap  ((GetDir #ui)+ "\\Icons\\"  + "Classic_16i.bmp")-- 位图的打开
  return a
  )
     ----------我在这里还要加入一个对于数据的控制 -------------------------
  --学习理论基础把控件名称变量成一个组,把控件名称变量的默认值成一个组,这样就好了 利用 打开和关闭进行数据的存储,这个效果很是好。


 pickbutton obj_btn "拾取表面物体" pos:[44,8] width:88 height:21

 button Tobj_pick "+" pos:[4,38] width:20 height:50 toolTip:"add selection Scatter Objects"
 button Tobj_del "-" pos:[4,93] width:20 height:15 toolTip:"Delete Scatter Object"
 listbox SCT_lit "" pos:[33,39] width:160 height:5 items:SCT_TargetOBJ
 spinner MinScale_spi "" pos:[60,128] width:55 height:16 range:[0,500,100]
 spinner MaxScale_spi "" pos:[130,128] width:55 height:16 range:[0,500,100]

 spinner MinRotateX_spi "" pos:[60,158] width:55 height:16 range:[-500,500,0]
 spinner MaxRotateX_spi "" pos:[130,158] width:55 height:16 range:[-500,500,0]
 spinner MinRotateY_spi "" pos:[60,178] width:55 height:16 range:[-500,500,0]
 spinner MaxRotateY_spi "" pos:[130,178] width:55 height:16 range:[-500,500,0]
 spinner MinRotateZ_spi "" pos:[60,198] width:55 height:16 range:[-500,500,0]
 spinner MaxRotateZ_spi "" pos:[130,198] width:55 height:16 range:[-500,500,0]

 spinner MinMove_spi "" pos:[60,228] width:55 height:16 range:[-10000,10000,0]
 spinner MaxMove_spi "" pos:[130,228] width:55 height:16 range:[-10000,10000,0]
 
 button ScaleIcon_btn "" pos:[20,125] width:20 height:20 images:#(load_icon() , undefined, 78, 25, 25, 1, 1)   
 --基本明白了 路径引用图片 通道图 有多少子图 可用时 做的输入 输出 不可用是桌的输入输出。
 button RotateIcon_btn "" pos:[20,175] width:20 height:20 images:#(load_icon(), undefined, 78, 23, 23, 1, 1)   
 button MoveIcon_btn "" pos:[20,226] width:20 height:20 images:#(load_icon(), undefined, 78, 21, 21, 1, 1)
 GroupBox ScaleGroup "" pos:[10,113] width:185 height:38
 GroupBox RotateGroup "" pos:[10,144] width:185 height:77
 GroupBox MoveGroup "" pos:[10,213] width:185 height:40
   
 spinner add_del_ "+_-" pos:[20,260] width:70 height:16 range:[-360,360,10] type:#integer
 spinner bugu_bul "paint_fu" pos:[40,280] width:70 height:16 range:[0,1200,100] type:#integer

 checkbutton start_btn "开始 !!" pos:[120,261] width:80 height:25

 timer clock "testClock" interval:50 --有钟表这个东西一切都来的好。

 -------------------繁重事件的处理-----------------------------------------
  global oop_sel_lingshi_edt_text =undefined
 
  on pick_obj_btn37  picked obj do

(
 if obj != undefined do
(
pick_obj_btn37.text = obj.name
)
)--end on

    on  copy_one_to_big_btn38 pressed do with undo on
 ( 
  if oop_sel_lingshi_edt_text!= undefined then
  (
  if oop_sel_lingshi_edt_text.count >0 then
  (
            if  pick_obj_btn37.text!=  "拾取繁重物体" then
   (    
   
   for i in 1 to oop_sel_lingshi_edt_text.count do
   (
    doit_prog.value = 100.*i/oop_sel_lingshi_edt_text.count
    ui_pick_obj =   execute( "$" + pick_obj_btn37.text)
    if ui_pick_obj ==undefined then
    (
     messageBox "节点丢失。"title:"盖天编写"
     return false
    )
    
    pp_cy = instance ui_pick_obj
    
    pp_cy.name = uniquename  ("instance_"+pick_obj_btn37.text)
    
    pp_cy.transform =oop_sel_lingshi_edt_text[i].transform
    
    
   )
      )
   
   
  )
  doit_prog.value = 0  
 )
 )
 
 
    local ctrlSp=#(MinScale_spi,MaxScale_spi,MinRotateX_spi,MaxRotateX_spi, MinRotateY_spi, MaxRotateY_spi,MinRotateZ_spi, MaxRotateZ_spi ,MinMove_spi,MaxMove_spi\
    ,add_del_,bugu_bul),
    spIni =#(100,100,0,0,0,0,0,0,0,0,10,100   )
  -----创建点到点的处理
  global oop_sel_lingshi_lenght=undefined

 on clock tick do ----开始时钟就走。
 (
  helperFN()
  newOBJcheckFN()

  if thePainterInterface.inPaintMode() == OFF do start_btn.checked=OFF
 )

 on MinMove_spi changed val do (
  try (delete $scatter_Helper )catch()  ----这里为什么盈动是要删除的,而缩放选择就是不用。
  TobjST.obj = undefined          -----我们一直是利用结构。我想结构其实就是一个全局变量,
 )
 on MaxMove_spi changed val do (
  try (delete $scatter_Helper )catch()
  TobjST.obj = undefined
 )

 on Tobj_del pressed do (
  try(
   delval = gt_Scatter_tool.SCT_lit.selection
   deleteitem  SCT_TargetOBJ  delval
  )catch()

  TobjName=for i in SCT_TargetOBJ collect i.name
  gt_Scatter_tool.SCT_lit.items = TobjName
 )

 on Tobj_pick  pressed do (
  objs= selection as array
  join  SCT_TargetOBJ  objs
  
  TobjName=for i in SCT_TargetOBJ collect i.name
  
  SCT_lit.items = TobjName ---这里是典型的加入节点,收集名字。
 )


 on obj_btn picked obj do (
  ScatOBJ = obj
  obj_btn.text = obj.name

  initFN_2()
 )


 on  start_btn  changed state do   (
  if gt_Scatter_tool.SCT_lit.items.count == 0 do return false ----列队数列0 什么不做
 --Box lengthsegs:1 widthsegs:1 heightsegs:1 length:43.4603 width:77.2628 height:25.9733 mapcoords:on
  if state == ON do initFN() ---这个是最开始事件,下来就是时间进行的一系列的变化。
  
  ---------------------------好像是错了在没有按下之前就已经是种再走了。
  
  if state == OFF do  (
   thePainterInterface.endPaintSession() ---关闭画笔 删除根部节点。
   try (delete $scatter_Helper )catch()
  )
 )
 
 on gt_Scatter_tool open  do for i=1 to ctrlSp.count do (v=getIniSetting "$plugcfg/gt_fan_zhi_bangding_.ini" "disturbSel" (ctrlSp[i] as string);ctrlSp[i].value=if v=="" then spIni[i] else v as float )
 on gt_Scatter_tool close do for i=1 to ctrlSp.count do  setINISetting   "$plugcfg/gt_fan_zhi_bangding_.ini" "disturbSel" (ctrlSp[i] as string) (ctrlSp[i].value as string)
 
 
)


------自动模型 
 function  gray_material_balk_wire =
   (
    oo_mat = selection as array
     for i in oo_mat do
     ( 
      --其实应该判断他有没有贴图 如果有就不好了 这里呢我就用名字代替下
      if   classof meditMaterials[1]== Standardmaterial and  meditMaterials[1].name == "Standardmaterial"then
      (
        i.material=meditMaterials[1]
       i.wirecolor = black
      )else
      (
        meditMaterials[1]= Standardmaterial()
       meditMaterials[1].name ="Standardmaterial"
        i.material=meditMaterials[1]
       i.wirecolor = black
      
      )
      --这个不好没戏合并时都是很费事 所哟我用材质球 进行 
     
      )
   )--end fn
   ----自动poly
    function four_face =
   (
  
   addModifier   $  (Turn_to_Poly())

   $.modifiers[1].limitPolySize=true
   $.modifiers[1].maxPolySize=4
 macros.run "Modifier Stack" "Convert_to_Poly"
   )
   ------box
    function gt_box_box =
  (
   oop= selection as array 
  
   for i in oop  do
   (
      i.boxmode =not  i.boxmode
     
   )  
  )
  ----xform
  fn gt_Xform_tt =
  (
   ---下面的过程需要算下。
   --1.先找到物体的transform
   --2.在把物体归零,加入修改器
   --3.在转动他的 Gizmo
   --4.把它进行塌陷
   
   --脚本中指处理了物体的旋转 还要处理物体的缩放。
   for i in selection do  
   (
    ---2011.4.18 我想加入对线 和体的 操作。对于别的不进行操作。
    if  (superClassOf i ==GeometryClass and  ClassOf i != Targetobject)  or   superClassOf i ==shape then
    (
     if  InstanceMgr.GetInstances i &instances != 1 then
     (
      if superClassOf i ==shape then macros.run "Modifier Stack" "Convert_to_Spline"
      
      if superClassOf i ==GeometryClass then convertTo i Editable_Poly
     )
    
    oo = [i.rotation.x_rotation ,i.rotation.y_rotation ,i.rotation.z_rotation ]
     --我在制作时改了思路 这下就好了
     pos_pos = i.pos

    i.rotation.x_rotation =0
    i.rotation.y_rotation=0
    i.rotation.z_rotation =0
    
    ---处理缩放
     secle_a = i.scale
               
    i.scale=[1,1,1]

    addModifier   i (XForm())

              
    i.modifiers[1].Gizmo[2].controller[1].value  =oo[1]
    i.modifiers[1].Gizmo[2].controller[2].value  =oo[2]
    i.modifiers[1].Gizmo[2].controller[3].value  =oo[3]
                
    i.modifiers[1].Gizmo[3].controller.value =secle_a
    
    

          convertTo i Editable_Poly
         )   
   )
   ---上面就是脚本解决的过程 这下我有知道Xform 深的理解
   
   
  )

 try(cui.UnRegisterDialogBar gt_mode_big)catch()-----这个是法则。
try (DestroyDialog gt_mode_big )catch()
rollout gt_mode_big "模型常用" width:160 height:132
(
 button Project_But "工程目录" pos:[29,4] width:92 height:18
 button an_mode_btn "自动模型" pos:[9,26] width:70 height:18
 button global_but "全局冻结" pos:[82,26] width:70 height:18
 button automation_btn "自动poly" pos:[9,48] width:70 height:18
 button box_btn "box盒" pos:[82,48] width:70 height:18
 button form_btn "归Xform" pos:[9,69] width:70 height:18
 button scatt_btn "散布" pos:[82,69] width:70 height:18
 
 on Project_But pressed do
 (
  SubPathNameList = #(#animations,#archives,#downloads,#export,#expression,#image,#import,#matlib,#maxstart,#Photometric,#preview,#proxies,#renderassets,#renderPresets,#renderoutput,#scene,#sound,#vpost)
for i in SubPathNameList  do
 SetDir i ( "."+"\\"+i as string)
pathConfig.doProjectSetupSteps()
  
  
 )---end on
 on an_mode_btn pressed do
 (
  gray_material_balk_wire()
 )---end on
 on global_but pressed do
 (
  try (
   function all_freeze_tan =
   (
    global all_obj_freeze


   oop  = selection as array
    if oop.count !=0 then
    (
    all_obj_freeze= oop
    )

      for i in all_obj_freeze do
   (
          i. isFrozen =not  i. isFrozen
      i.showFrozenInGray =false
    -- i.showFrozenInGray = not i.showFrozenInGray
   )  
   )
   all_freeze_tan()
          )catch( messagebox ("全局变量已换。"))
  
 )-----end on
 on automation_btn pressed do
 (
   try (four_face ()) catch ()
 )---end on
 on box_btn pressed do
 (
   try ( gt_box_box()) catch ()
 )---end on
 on form_btn pressed do
 (
   try ( gt_Xform_tt()) catch ()
 )---end on
 on scatt_btn pressed do
 (

createdialog gt_Scatter_tool style:#(#style_titlebar, #style_border, #style_sysmenu,#style_minimizebox )

 )---end on
 
 
)
----***************************************************************************
---------*****************变换轴心点**************************************************************-----------
 try(cui.UnRegisterDialogBar transPivot)catch()-----这个是法则。
try (DestroyDialog transPivot )catch()
global gt_yc_Ail
 fn g_filter o = superclassof o == Geometryclass
 fn find_intersection z_node node_to_z =
 (
  try(
  --同样的条件 数字及计算要比字符串快 所以能用数字 不用字符串。
  ---改写成自动的循环处理的, 我考虑的因为只有6 个 所有用循环擦看。
  local oop
         local  compare_array =#()  
  for i in 1 to 6 do
  (
 oop=case of

   (

   (i==1): [0,0,-1]

   (i ==2): [0,0,1]
    
   (i ==3):[-1,0,0]
    
   (i==4):[1,0,0]
    
   (i ==5):[0,-1,0]
    
   (i ==6):[0,1,0]

   --default: reference $foo
   )
  -- print oop

  local testRay = ray node_to_z.pos  oop
  local nodeMaxZ
  
   case oop  of
   (  ------Z 轴
    ([0,0,-1]) :(nodeMaxZ = z_node.max.z
     testRay.pos.z = nodeMaxZ + 0.0001 * abs nodeMaxZ
     
     )
    ([0,0,1]) :(nodeMaxZ = z_node.min.z
     testRay.pos.z = nodeMaxZ - 0.0001 * abs nodeMaxZ  
    )
    -------X轴 
    ([-1,0,0]) : (nodeMaxZ = z_node.max.x
     testRay.pos.x = nodeMaxZ + 0.0001 * abs nodeMaxZ   
    )
    ([1,0,0]) : (nodeMaxZ = z_node.min.x
    testRay.pos.x = nodeMaxZ - 0.0001 * abs nodeMaxZ   
    )
   ------- Y轴
          ([0,-1,0]) : (nodeMaxZ = z_node.max.y
    testRay.pos.y = nodeMaxZ + 0.0001 * abs nodeMaxZ   
    )
    ([0,1,0]) : (nodeMaxZ = z_node.min.y
    testRay.pos.y = nodeMaxZ - 0.0001 * abs nodeMaxZ   
    ) 
   )
   
       
  --)
  --testRay.pos.z = nodeMaxZ + 0.0001 * abs nodeMaxZ
    if  intersectRay z_node testRay !=undefined then
    (
     ---因为我先做了x轴的负方向 其实两个方向是同事存在了 所有 好要进行比较了
    --return
       append  compare_array  (intersectRay z_node testRay)
    
   --  exit
    
    )
    
       
   
  )/*
   for i in compare_array do
   (
   distance_d =   distance  $selection[1].pos  i.pos
  --print compare_array[1].pos
    distance_c=0
    if distance_d>= distance_c then
    (
      distance_c =distance_d
    )
   
   )*/
  ---其实就有两个我比较下好; 用列举法
   distance_d =   distance  $selection[1].pos  compare_array[1].pos
  try ( distance_c =   distance  $selection[1].pos  compare_array[2].pos )
  catch ( distance_c =distance_d+20)
    if amin distance_d  distance_c == distance_d then
    (
     return compare_array[1]
    )else
    (
     return compare_array[2]
    )
   ) catch ()
  
 )
rollout transPivot "变换轴心点" width:160 height:344
(
 
 local alignToObj=0,
    usePivot
 pickbutton alObj "alignTo:(onesel/...)" pos:[4,4] width:104 height:15
 button alSel "清除" pos:[114,4] width:35 height:15
 button al5 "X_max" pos:[4,30] width:70 height:18
 button al6 "X_min" pos:[81,29] width:70 height:18
 button al1 "Y_max" pos:[4,52] width:70 height:18
 button al3 "Y_min" pos:[81,51] width:70 height:18
 button al2 "Z_max" pos:[4,74] width:70 height:18
 button al4 "Z_min" pos:[81,73] width:70 height:18
 button alc "中心" pos:[4,96] width:70 height:18
 button alR "随机" pos:[81,95] width:70 height:18
 spinner mult "倍率" pos:[10,119] width:55 height:16 range:[0,10,1]
 spinner multR "倍率随机" pos:[85,120] width:70 height:16 range:[0,10,0]
 button pick_btn1 "自动对齐" pos:[40,142] width:70 height:18 enabled:true
 
 ----------------------
 fn rotatePivotOnly obj rotation =
 (
  local rotValInv=rotation as quat
  animate off
  in coordsys local obj.rotation*=RotValInv
  obj.objectoffsetrot*=RotValInv
  obj.objectoffsetpos*=RotValInv
 )
 on alObj picked obj do (alignToObj= obj; alObj.text=("alignTo: "+obj.name); sel=getCurrentSelection(); for i=1 to sel.count do (resetPivot sel[i];  rotatePivotOnly sel[i] alignToObj.rotation;  sel[i].pivot=alignToObj.pivot) )
 on alSel pressed do (alignToObj=0; alObj.text="alignTo:(onesel/...)")
 on al1 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.y=obj.max.y+(mult.value-1+random 0.0 multR.value)*(obj.max.y-obj.min.y) ) )
 on al2 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.z=obj.max.z+(mult.value-1+random 0.0 multR.value)*(obj.max.z-obj.min.z) ) )
 on al3 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.y=obj.min.y-(mult.value-1+random 0.0 multR.value)*(obj.max.y-obj.min.y) ) )
 on al4 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.z=obj.min.z-(mult.value-1+random 0.0 multR.value)*(obj.max.z-obj.min.z) ) )
 on al5 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.x=obj.max.x+(mult.value-1+random 0.0 multR.value)*(obj.max.x-obj.min.x) ) )
 on al6 pressed do ( sel=getCurrentSelection(); for i=1 to sel.count do (obj=if alignToObj==0 then sel[i] else alignToObj; sel[i].pivot.x=obj.min.x-(mult.value-1+random 0.0 multR.value)*(obj.max.x-obj.min.x) ) )
 on alc pressed do (
      sel=getCurrentSelection()
      for i=1 to sel.count do
      (
       obj=if alignToObj==0 then sel[i] else alignToObj
       sel[i].pivot.x=obj.min.x+0.5*(obj.max.x-obj.min.x); sel[i].pivot.y=obj.min.y+0.5*(obj.max.y-obj.min.y); sel[i].pivot.z=obj.min.z+0.5*(obj.max.z-obj.min.z) )
     )
 on alr pressed do (
      sel=getCurrentSelection()
      for i=1 to sel.count do
      (
       obj=if alignToObj==0 then sel[i] else alignToObj
       sel[i].pivot.x=random (obj.min.x-(mult.value-1+random 0.0 multR.value)*(obj.max.x-obj.min.x)) (obj.max.x+(mult.value-1+random 0.0 multR.value)*(obj.max.x-obj.min.x))
       sel[i].pivot.y=random (obj.min.y-(mult.value-1+random 0.0 multR.value)*(obj.max.y-obj.min.y)) (obj.max.y+(mult.value-1+random 0.0 multR.value)*(obj.max.y-obj.min.y))
       sel[i].pivot.z=random (obj.min.z-(mult.value-1+random 0.0 multR.value)*(obj.max.z-obj.min.z)) (obj.max.z+(mult.value-1+random 0.0 multR.value)*(obj.max.z-obj.min.z))
      )
     )
     
   on pick_btn1 pressed do
 (
  ---从上到下执行。先执行这里的这个。
  target_mesh = pickObject message:"Pick Target Surface:" filter:g_filter --- 这种拾取的方法更好。不用再显示;
  if isValidNode target_mesh then ---这个好用, 是如果节点没有被删除。
  (
   undo "MoveToSurface" on
   (
    for i in selection do
    (
     int_point = find_intersection target_mesh i
   -- print  int_point as string
     if int_point != undefined and  int_point != ok then
   (
   i.pos = int_point.pos
   -- print int_point.pos
  )
    )--end i loop
   )--end undo
  )--end if
 )--end pressed     
 on transPivot open do ( usePivot=getCoordCenter(); toolMode.pivotCenter() )
 on transPivot close do case usePivot of( #local:toolMode.pivotCenter(); #selection:toolMode.selectionCenter(); #system:toolMode.transformCenter() )
)--end rollout

--********************************************************************************


---看到别人的东西是根据选择体的线,选择相应的体中的线。
--1.选择线判断两点距离。其实这我也就明白了容差在这里到底是什么意思。---、
--2.把模型的所有点找到。做递归的两点距离判断。 在容差范围内的,看看是否能还原出线。如果不行就没事。如果行就加到数组中
--3.进行选择。
--4. 关与线的方式我想不出来什么 我觉得就是递增判断距离。--其实后来我用的不是那个。是用的循环线。
 
 --判断物体收集所以线
 --因为每条线都有两个点,判断线的距离。
 
 fn Equal_spline input_poly tolerance =   ---这个函数是查找相等的线,input_poly 是输入的模型信息,判断是poly tolerance 容差数子。
  --在一定范围内的线被选择。
 (
    local line_space =0 --初始化间距
    local endge_length_array =#() ---收集的线的长度数组。
  --只对于是poly 或者是mesh
  if  superclassof input_poly ==GeometryClass  then
  (
    if classof input_poly == Editable_Poly then  --polyop.getEdgeSelection --这个以后还有很到的改善的地方,主要应用于层级的poly mesh
    (
    ---求的总边数
             oop_Eng =  polyop.getNumEdges  input_poly
             
            ---先判断第一个边。找起长度。在进行循环比较
              Edge_array = polyop.getEdgeSelection  input_poly  as array --转成数组好判断个数这个很好。
     if Edge_array.count == 1 then
     (
    
      verts_array = polyop.getEdgeVerts input_poly  Edge_array[1] ---返回边的顶点。--着是个数组
      ---还有这里肯定是两个点的数组。所以我在这里直接用索引就好了。
     
      ---判断距离
     
       date_dis_1 = polyop.getVert  input_poly  verts_array[1]
       date_dis_2 = polyop.getVert  input_poly  verts_array[2]
     
         line_space = distance  date_dis_1 date_dis_2
        -- line_space=line_space+tolerance
      
     )else  return false
               
     ---这里面做循环判断间距。距离在一定范围内加入数组。
     for i in 1 to oop_Eng do ---对每个边进行循环,也就是说,要有很多的point 数组产生 这里要进行长度判断。
     (
      verts_array = polyop.getEdgeVerts input_poly i
     
       date_dis_3 = polyop.getVert  input_poly  verts_array[1]
       date_dis_4 = polyop.getVert  input_poly  verts_array[2]
     
       local_line_space =distance  date_dis_3 date_dis_4
      ---这里要明白一点容差是上下的。所有这里有不同。
     
         tolerance_shang = line_space+tolerance
         tolerance_xia =line_space-tolerance
      
       if local_line_space <=tolerance_shang  and  local_line_space>=tolerance_xia   then ---
       (
         endge_length_array[(endge_length_array.count) +1]= i
       
       )
                     
     
     )---end for oop_Eng
     ---选择边的数组就好
    
     polyop.setEdgeSelection input_poly  endge_length_array
      nodeInvalRect input_poly
 
    )--end classof poly
   
    ---同样在里面找到上面的函数应用到mesh
    --1.返回返回mesh的所有的边数
    --2.对当前的选择边转数组
    --3.比较距离。(这里面中要的是能找到返回点的坐标的函数)
    --4. 循环比较做处理。
    ---我现在的感觉是,搭建物体形体最好是用mesh 编辑物体最好到poly
   
  ---mesh 没有相应转换的参数。所以要是进行比较就比较困难了。这里就制作 poly 的编辑。
  
  )---end if
 
 
 )---end fn
 
 ----下面是根据面的大小做判断,根据面积 ,其实这个函数最好的就是对正边形做判断。处理。
 ---- 原来是利用面的返回值做计算
 fn  Equal_face  input_poly  tolerance = --函数 变量 input_face 是输入的poly tolerance 是容量的大小
 ( 
  local line_space_area =0 --初始化面积。
  local append_faces_area = #()
 
   if  superclassof input_poly ==GeometryClass  then
  (
    if classof input_poly == Editable_Poly then  --polyop.getEdgeSelection --这个以后还有很到的改善的地方,主要应用于层级的poly mesh
    (
     ---求总的面数
     total_output_face =  polyop.getNumFaces input_poly
       ---判断当前的面返回的点。是一个数组 非别是三点 四点 和多点
      being_Verts= polyop.getFaceSelection  input_poly as array
     if being_Verts.count==1 then ---确保选择的是一个面,这个处理的效果非常的好。
     ( 
     
     
       being_Verts_array =  polyop.getFaceVerts  input_poly   being_Verts[1]
       ----数量的表达
       being_Verts_array_count = being_Verts_array.count
       
        case being_Verts_array_count  of
     (
                        3:(
       ---因为这里返回的是点,还是需要用距离算出来。
                 date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                 date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
        date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
       
         line_space = distance  date_dis_1 date_dis_2
         line_space_1 = distance  date_dis_1 date_dis_3
         ---我做出了两个间距。下面我就计算假性的面积
        line_space_area = line_space *line_space_1 /2
       
       
       
      )
      4:(
         date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                  date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
         date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
         date_dis_4 = polyop.getVert  input_poly  being_Verts_array[4]
        ----这里面当做矩形看待处理面积
          line_space = distance  date_dis_1 date_dis_2
          line_space_1 = distance  date_dis_3 date_dis_4
        line_space_area = line_space *line_space_1
       
      )
      ----当等于5 6 7 8 时就是按下面的进行计算。
      default:(
       ----对于多个面的我同样是 假性的算出 矩形的面积。来处理
         date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                  date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
         date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
         date_dis_4 = polyop.getVert  input_poly  being_Verts_array[4]
        ----这里面当做矩形看待处理面积
          line_space = distance  date_dis_1 date_dis_2
          line_space_1 = distance  date_dis_3 date_dis_4
          line_space_area = line_space *line_space_1
       
       
      )

     )----case  of  
     -------------------下面就是循环处理所有面,通过比较面积处理。

     
   
     )else return false
    
      for i in 1 to total_output_face do
      (
       ---在查询面时同样也是要建立一个空组。
         being_Verts_array =  polyop.getFaceVerts  input_poly   i
       ----数量的表达
    ----通过测试表明,如果形体架线不正确,那么可能返回的面数很多,但是其实在面里又返回不了点 就会出现 undefined
       --所以加入排错
       if being_Verts_array ==undefined do  Continue
       being_Verts_array_count = being_Verts_array.count
       
        case ( being_Verts_array_count)  of
     (
                        3:(
       ---因为这里返回的是点,还是需要用距离算出来。
                 date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                 date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
        date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
       
         line_space = distance  date_dis_1 date_dis_2
         line_space_1 = distance  date_dis_1 date_dis_3
         ---我做出了两个间距。下面我就计算假性的面积
        local_line_space_area = line_space *line_space_1 /2
       if local_line_space_area <= line_space_area+tolerance and local_line_space_area >= line_space_area - tolerance  then
       (
                 append  append_faces_area i
        
        
       )
       
      )
      4:(
         date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                  date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
         date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
         date_dis_4 = polyop.getVert  input_poly  being_Verts_array[4]
        ----这里面当做矩形看待处理面积
          line_space = distance  date_dis_1 date_dis_2
          line_space_1 = distance  date_dis_3 date_dis_4
         local_line_space_area = line_space *line_space_1
       if local_line_space_area <= line_space_area+tolerance and local_line_space_area >= line_space_area - tolerance  then
       (
                 append  append_faces_area i
        
        
       )
       
      )
      ----当等于5 6 7 8 时就是按下面的进行计算。
      default:(
       ----对于多个面的我同样是 假性的算出 矩形的面积。来处理
         date_dis_1 = polyop.getVert  input_poly  being_Verts_array[1]
                  date_dis_2 = polyop.getVert  input_poly  being_Verts_array[2]
         date_dis_3 = polyop.getVert  input_poly  being_Verts_array[3]
         date_dis_4 = polyop.getVert  input_poly  being_Verts_array[4]
        ----这里面当做矩形看待处理面积
          line_space = distance  date_dis_1 date_dis_2
          line_space_1 = distance  date_dis_3 date_dis_4
           local_line_space_area = line_space *line_space_1
       if local_line_space_area <= line_space_area+tolerance and local_line_space_area >= line_space_area - tolerance  then
       (
                 append  append_faces_area i
        
        
       )
       
       
      )

     )----case  of
     
      
      )--end for face
     
      ---通过上面完成面的收集 ,下来就是进行选择处理。
      polyop.setFaceSelection  input_poly  append_faces_area
                   nodeInvalRect input_poly
    
    )--enfd  poly
 
  ) ----end if super classof
 )---end fn
 
 ----对于边面的选择机制 ,我 还是要加入数组的相加处理的,这点很重要。
global vertex_cun_gt =#(),edge_cun_gt =#(),polygon_cun_gt =#()

 try(cui.UnRegisterDialogBar gt_up_down_select)catch()-----这个是法则。
try (DestroyDialog gt_up_down_select )catch()
rollout gt_up_down_select  "容差选择" width:160 height:89
(
 spinner up_down_num_spn "上下容差值:" pos:[11,5] width:135 height:16 range:[0,1e+008,0.01] type:#float scale:0.00001
 button equal_lenght_btn "同长度的边选择" pos:[16,27] width:122 height:18
 button equal_face_btn "同面积的面选择" pos:[18,53] width:122 height:18
 
 groupBox grp1 "因素内存" pos:[5,73] width:151 height:93
 button xuan_btn1 "选" pos:[10,133] width:35 height:19
 
 
 
 button dian_btn1 "点+" pos:[10,111] width:35 height:19
 button qing1 "清" pos:[10,91] width:35 height:19
 button xuan_btn2 "选" pos:[57,133] width:35 height:19
 
 
 
 button bian_btn1 "边+" pos:[57,111] width:35 height:19
 button qing2 "清" pos:[57,91] width:35 height:19
 button xuan_btn3 "选" pos:[103,133] width:35 height:19
 
 
 
 button mian_btn1 "面+" pos:[103,111] width:35 height:19
 button qing3 "清" pos:[103,91] width:35 height:19
 on qing1 pressed do
 (
  vertex_cun_gt =#()
 )
 on qing2 pressed do
 ( -- print "22222222222222"  ----max看来又是也会变量有问题
  
  edge_cun_gt =#()
  
 )
 
 on qing3 pressed do
 (
  polygon_cun_gt =#()
 )
 
 on xuan_btn1 pressed do
 (
  try (polyop.setVertSelection $  vertex_cun_gt
      nodeInvalRect $
   )catch ()
 )
 on xuan_btn2 pressed do
 (
  try (polyop.setEdgeSelection  $  edge_cun_gt
   nodeInvalRect $
   )catch ()
 )
 on xuan_btn3 pressed do
 (
  try (polyop.setFaceSelection   $  polygon_cun_gt
             nodeInvalRect $
   )catch ()
 )
  on dian_btn1 pressed do
 (
  try (
   vertex_cun_gt +=( polyop.getVertSelection $ )as array  ---数组中有重复的显现 就这样了 要是循环在处理我觉得肯能算的会慢。
   --vertex_cun_gt += vertex_cun_gt
   
   
   
   )catch ()
 )
   on bian_btn1 pressed do
 (
  try (
   edge_cun_gt +=(polyop.getEdgeSelection  $ )as array  ---数组中有重复的显现 就这样了 要是循环在处理我觉得肯能算的会慢。
   --vertex_cun_gt += vertex_cun_gt
   
   
   
   )catch ()
 )
 on mian_btn1 pressed do
 (
  try (
   polygon_cun_gt +=(polyop.getFaceSelection  $ )as array  ---数组中有重复的显现 就这样了 要是循环在处理我觉得肯能算的会慢。
   --vertex_cun_gt += vertex_cun_gt
   
   
   
   )catch ()
 )
 
 
 
 
 
 on equal_lenght_btn pressed do
 (
  Equal_spline $ up_down_num_spn.value
 )---end on
  on equal_face_btn pressed do
 (
  Equal_face $ up_down_num_spn.value
 )---end on
 
 
 
)

----------********************************************************

---段数的跳一个 选择一个,这样进行处理。点数的,面数的处理
---起初我是这么想的。用when 语句进行操作,单我按下按钮时,就是这样的,当我点击的线符合拓扑结构时。
---产生横向与纵向的连长,但是我后来就不这么想了。
---尤其是在听了路生的教导后。我不想在刷什么。我要做的工作是,在max的基础上,做东西。补不足。 max 能实现的,大家都在用,所以习惯了,
---不是很好改了。
---好了,写东西了。起初只是想写线的,现在看来,我要写 点的 边的, 面的  奇数 偶数的选择。2011.4.22 晚
---由于在选择中选择缺口 返回的是边,所以 所以这样按缺口选择的 估计有特定的函数,或有特定的组,
---这个我在后卖在考虑。
 fn odd_numbers_even_numbers input_poly type_t  odd_even  num  =
 (
  ---结构是点 边 面   在往下就是 奇数性 还有就是偶数性
  
    case of ---这个是我的手动的处理。所以这里面我只列举3 中情况进行处理。
  (

  (type_t == "select_vertex"):(
   
   local mod_array =#()
   local mod_back_array =#()
    Back_Verts_array = polyop.getVertSelection  input_poly
    Back_Verts_array =Back_Verts_array as array
   if Back_Verts_array.count !=0 then
   (
    Back_Verts_array =sort  Back_Verts_array --数组排列方便选择。
    
    for i in 1 to Back_Verts_array.count do
    (
     if  (mod  i num )as integer ==0 then
     (
         append   mod_array   Back_Verts_array[i]
      
     )else
     (
      append   mod_back_array   Back_Verts_array[i]
      
     )---end else
     
    )---end for
    
   
   
   if odd_even=="odd"then
   (
     polyop.setVertSelection   input_poly  mod_back_array
     nodeInvalRect input_poly
   )--end odd
   if odd_even=="even" then
   (
     polyop.setVertSelection   input_poly  mod_array
     nodeInvalRect input_poly
   )---end enen
   )----end back_vertex_array
   
  )---end ()
  (type_t == "select_edge"):(
   local mod_array =#()
   local mod_back_array =#()
    Back_Verts_array = polyop.getEdgeSelection  input_poly
    Back_Verts_array =Back_Verts_array as array
   if Back_Verts_array.count !=0 then
   (
    Back_Verts_array =sort  Back_Verts_array --数组排列方便选择。
    
    for i in 1 to Back_Verts_array.count do
    (
     if  (mod  i num )as integer ==0 then
     (
         append   mod_array   Back_Verts_array[i]
      
     )else
     (
      append   mod_back_array   Back_Verts_array[i]
      
     )---end else
     
    )---end for
    
   
   
   if odd_even=="odd"then
   (
     polyop.setEdgeSelection   input_poly  mod_back_array
     nodeInvalRect input_poly
   )--end odd
   if odd_even=="even" then
   (
     polyop.setEdgeSelection   input_poly  mod_array
     nodeInvalRect input_poly
   )---end enen
   
   )----end back_vertex_array
   
  )---end ()
  (type_t == "select_polygon"):(
   
   local mod_array =#()
   local mod_back_array =#()
    Back_Verts_array = polyop.getFaceSelection  input_poly
    Back_Verts_array =Back_Verts_array as array
   if Back_Verts_array.count !=0 then
   (
    Back_Verts_array =sort  Back_Verts_array --数组排列方便选择。
    
    for i in 1 to Back_Verts_array.count do
    (
     if  (mod  i num )as integer ==0 then
     (
         append   mod_array   Back_Verts_array[i]
      
     )else
     (
      append   mod_back_array   Back_Verts_array[i]
      
     )---end else
     
    )---end for
    
   
   
   if odd_even=="odd"then
   (
     polyop.setFaceSelection   input_poly  mod_back_array
     nodeInvalRect input_poly
   )--end odd
   if odd_even=="even" then
   (
     polyop.setFaceSelection   input_poly  mod_array
     nodeInvalRect input_poly
   )---end enen
   
   )else return  false ----end back_vertex_array
   
   
   
  )---end ()


   )---enf case
 )---end fn
 
---我觉得点的选择可以由面点会来,这个就不用写了。其实原来也是有面转成点,这个不是很费时间。
---我做的工具也是配合max 的命令一期操作的,所以这个就不选了。

 ------------------------------------------------------------------------------------- 
  
  
fn max_2011_mode_style input_poly type_t ring_and_loop  by_num =
(

---针对于我想的这里算法。来对点线面进行处理。我的方法就是
--1.(先以线为例说明点和面都是这里过度的。)试验的对像确保是一个可操作的对象结构。
--2.得知序列返回数组,返回之前选择的 组内对应的号数。 在组内做递加 和递减 最小不能小于1 最大不能超过组本身的数
--3.两个数组相加 在进行边的选择,
--4.之后依次展开 处理。
--5.结构是:
---------------1. 点线面的大结构
---------------2.在处理横选择 还是纵选择的问题
---------------3. 选择处理
  case of ---这个是我的手动的处理。所以这里面我只列举3 中情况进行处理。
  (
   
  (type_t == "select_vertex"):(
   ---2011.4.23 2.35 对于点击莫一个线向外边散开,隔一个选择一个思路我是有了。
   
   --在这个的操作中,对于线我已经做好,对于面我可以转换成线,在操作,最后在返回面,造成
   --假象上的对于面的处理。其实还是从线的方式出发。
   --对于点 在转换成线的过程中,就不是很好办理。我是可以通过线 转点在选择点,
   --从研究上来说是可行的,但是从应用 和美术来说极为不好,所以这部分呢不写 不要了。
   --想要的效果同样是能做出来。
   
  )---end ()

  (type_t == "select_edge"):(
   ---2011.4.23 2.35 对于点击莫一个线向外边散开,隔一个选择一个思路我是有了。
   ---判断选择线是一个进行操作,这个是我要的效果。
   local up_array =#()
   local down_array = #()
   local total_array =()---向上向下的数组加在一起,就是我要选择的东西。
   
   
   Back_Verts_array = polyop.getEdgeSelection  input_poly
   Back_Verts_array=Back_Verts_array as array
   if  Back_Verts_array.count !=0 then
   (
   if ring_and_loop=="ring"then
   (
    for each in 1 to  Back_Verts_array.count do
    (  
      linshi =#()
    --查看现在选择的号数,和之前的查找编号。如果数组的个数小于两个是什么都不做的。
    form_Back_Verts_array= Back_Verts_array[each] ---这里面保证是一个。
     ----这里要选择。
     linshi[1]=form_Back_Verts_array
      polyop.setEdgeSelection   input_poly  linshi
     
     input_poly.EditablePoly.SelectEdgeRing ()
    ---加入循环命令。
    
    now_Back_Verts_array = polyop.getEdgeSelection  input_poly
    now_Back_Verts_array=now_Back_Verts_array as array
    now_Back_Verts_array_count =now_Back_Verts_array.count ---数量
    ---下一步就是查找顶点所在的个数,在一个模型中,顶点数组肯定是不会有重复的。
    if now_Back_Verts_array_count <3 then return false ----如果数组中就这有两个的话
     ---循环 隔选就没有意义了。
    
    ----在数组中查找肯定是能查找出来,这个是肯定的。
     unm_edge = findItem   now_Back_Verts_array  form_Back_Verts_array
    -----寄存选择的线在数组中的位置。
    local true_tt =true
    while true_tt do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge+=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge<= now_Back_Verts_array_count then
     (
     append up_array now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge>=now_Back_Verts_array_count then
     (
      true_tt=false
      
     )
     
    )---end while
    
    local true_true =true
    while true_true do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge-=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge >=1 then
     (
     append down_array  now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge <=1 then
     (
      true_true=false
      
     )
    
     
    )---end while
    total_array =up_array +down_array +Back_Verts_array
    total_array+=total_array
   )

     polyop.setEdgeSelection   input_poly  total_array
     nodeInvalRect input_poly
   )----end if ring
   
   
   if ring_and_loop=="loop"then
   (
    for each in 1 to  Back_Verts_array.count do
    (  
      linshi =#()
    
    --查看现在选择的号数,和之前的查找编号。如果数组的个数小于两个是什么都不做的。
    form_Back_Verts_array= Back_Verts_array[each] ---这里面保证是一个。
     linshi[1]=form_Back_Verts_array
      polyop.setEdgeSelection   input_poly  linshi
     input_poly.EditablePoly.SelectEdgeLoop ()
    ---加入循环命令。
     
     
    
    now_Back_Verts_array = polyop.getEdgeSelection  input_poly
    now_Back_Verts_array=now_Back_Verts_array as array
    now_Back_Verts_array_count =now_Back_Verts_array.count ---数量
    ---下一步就是查找顶点所在的个数,在一个模型中,顶点数组肯定是不会有重复的。
    if now_Back_Verts_array_count <3 then return false ----如果数组中就这有两个的话
     ---循环 隔选就没有意义了。
    
    ----在数组中查找肯定是能查找出来,这个是肯定的。
     unm_edge = findItem   now_Back_Verts_array  form_Back_Verts_array
    -----寄存选择的线在数组中的位置。
    local true_tt =true
    while true_tt do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge+=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge<= now_Back_Verts_array_count then
     (
     append up_array now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge>=now_Back_Verts_array_count then
     (
      true_tt=false
      
     )
     
    )---end while
    
    local true_true =true
    while true_true do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge-=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge >=1 then
     (
     append down_array  now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge <=1 then
     (
      true_true=false
      
     )
    
     
    )---end while
    total_array =up_array +down_array +Back_Verts_array
    total_array+=total_array
   )

     polyop.setEdgeSelection   input_poly  total_array
     nodeInvalRect input_poly
   )----end if loop
   
   
  )---end if back_vertx_array.count
    
  )---end ()

  (type_t == "select_polygon"):(
   ---2011.4.23 2.35 对于点击莫一个线向外边散开,隔一个选择一个思路我是有了。
   
   ---判断选择线是一个进行操作,这个是我要的效果。
   local up_array =#()
   local down_array = #()
   local total_array =()---向上向下的数组加在一起,就是我要选择的东西。
   
   
   Back_Verts_array = polyop.getFaceSelection input_poly
   Back_Verts_array=Back_Verts_array as array
   if  Back_Verts_array.count !=0 then
   (
   if ring_and_loop=="ring"then
   (
    for each in 1 to  Back_Verts_array.count do ---这里是面数。
    (  
     -- linshi =#() 
    ---加入循环命令。
    --查看现在选择的号数,和之前的查找编号。如果数组的个数小于两个是什么都不做的。
    form_Back_Verts_array= Back_Verts_array[each] ---这里面保证是一个。
    --input_poly.EditablePoly.SelectEdgeRing ()
    --用面返回边,用边做循环 返回面,在进行面的处理。
    polygon_to_edge_array = polyop.getFaceEdges input_poly  form_Back_Verts_array
    ---返回的第一个是ring 第二个是loop
     polyop.setEdgeSelection  input_poly  polygon_to_edge_array[1]--这里是转折点
     input_poly.EditablePoly.SelectEdgeRing ()
    input_poly.EditablePoly.ConvertSelection  #Edge #Face --转成面
    
    now_Back_Verts_array = polyop.getFaceSelection  input_poly
    now_Back_Verts_array=now_Back_Verts_array as array
    now_Back_Verts_array_count =now_Back_Verts_array.count ---数量
    ---下一步就是查找顶点所在的个数,在一个模型中,顶点数组肯定是不会有重复的。
    if now_Back_Verts_array_count <3 then return false ----如果数组中就这有两个的话
     ---循环 隔选就没有意义了。
    
    ----在数组中查找肯定是能查找出来,这个是肯定的。
     unm_edge = findItem   now_Back_Verts_array  form_Back_Verts_array
    -----寄存选择的线在数组中的位置。
    local true_tt =true
    while true_tt do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge+=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge<= now_Back_Verts_array_count then
     (
     append up_array now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge>=now_Back_Verts_array_count then
     (
      true_tt=false
      
     )
     
    )---end while
    
    local true_true =true
    while true_true do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge-=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge >=1 then
     (
     append down_array  now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge <=1 then
     (
      true_true=false
      
     )
    
     
    )---end while
    total_array =up_array +down_array +Back_Verts_array
    total_array+=total_array
    
   )

     polyop.setFaceSelection  input_poly  total_array
      nodeInvalRect input_poly
   )----end if ring
   
   
   if ring_and_loop=="loop"then
   (
    
     for each in 1 to  Back_Verts_array.count do ---这里是面数。
    ( 
    ---加入循环命令。
    --查看现在选择的号数,和之前的查找编号。如果数组的个数小于两个是什么都不做的。
    form_Back_Verts_array= Back_Verts_array[each] ---这里面保证是一个。
    --input_poly.EditablePoly.SelectEdgeRing ()
    --用面返回边,用边做循环 返回面,在进行面的处理。
    polygon_to_edge_array = polyop.getFaceEdges input_poly  form_Back_Verts_array
    ---返回的第一个是ring 第二个是loop
     polyop.setEdgeSelection  input_poly  polygon_to_edge_array[2]--这里是转折点
    -- input_poly.EditablePoly.SelectEdgeLoop ()
    input_poly.EditablePoly.SelectEdgeRing ()---这里我变化了数组个数所以都是要ring
    input_poly.EditablePoly.ConvertSelection  #Edge #Face --转成面
    
    now_Back_Verts_array = polyop.getFaceSelection  input_poly
    now_Back_Verts_array=now_Back_Verts_array as array
    now_Back_Verts_array_count =now_Back_Verts_array.count ---数量
    ---下一步就是查找顶点所在的个数,在一个模型中,顶点数组肯定是不会有重复的。
    if now_Back_Verts_array_count <3 then return false ----如果数组中就这有两个的话
     ---循环 隔选就没有意义了。
    
    ----在数组中查找肯定是能查找出来,这个是肯定的。
     unm_edge = findItem   now_Back_Verts_array  form_Back_Verts_array
    -----寄存选择的线在数组中的位置。
    local true_tt =true
    while true_tt do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge+=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge<= now_Back_Verts_array_count then
     (
     append up_array now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge>=now_Back_Verts_array_count then
     (
      true_tt=false
      
     )
     
    )---end while
    
    local true_true =true
    while true_true do
    ( 
     --append up_array 这里面我为什么想放在这里,我是怕溜掉了unm_edge
     --后来想想他还像下循环,都这样的话旧哟哟重复的了
     -- 这里我不查找数组的重复,我最后做个加法运算。加上他就行了,这样快。
     unm_edge-=by_num
     ----这里就是循环一遍把东西往数组中加入一遍。
     if unm_edge >=1 then
     (
     append down_array  now_Back_Verts_array[unm_edge]
     )
     
     if unm_edge <=1 then
     (
      true_true=false
      
     )
    
     
    )---end while
    total_array =up_array +down_array +Back_Verts_array
    total_array+=total_array
   )

     polyop.setFaceSelection  input_poly  total_array
                 nodeInvalRect input_poly
    
   )----end if loop
   
   
     )---end if back_vertx_array.count
 
  )---end ()    
   
  )----end case

 
)-------end fn max_2011


 try(cui.UnRegisterDialogBar gt_element__)catch()-----这个是法则。
try (DestroyDialog gt_element__ )catch()
rollout gt_element__ "编辑步幅因素" width:160 height:297
(
  
  fn  load_icon  = (
  a=openbitmap  ((GetDir #ui)+ "\\Icons\\"  + "EditMesh_24i.bmp")-- 位图的打开
  return a
  )
 spinner guolu_spn "步幅" pos:[14,57] width:54 height:16 enabled:true range:[0,100,2] type:#integer scale:0.1
 button select_edge_even_btn "奇" pos:[72,57] width:40 height:20
 button select_face_odd_btn "偶" pos:[112,57] width:40 height:20
 spinner max_2011_spn "间隔" pos:[15,142] width:54 height:16 enabled:true range:[0,100,2] type:#integer scale:0.1
 button select_edge_ring_btn "ring" pos:[71,142] width:40 height:20
 button select_edge_loop_btn "loop" pos:[111,142] width:40 height:20
 GroupBox grp10 "奇偶选择" pos:[2,1] width:155 height:84
 
 
 checkbutton select_vertex_odd_btn "" pos:[23,25] width:24 height:24  images:#(load_icon() , undefined, 10, 1, 6, 1, 1)   
 checkbutton select_vertex_even_btn "" pos:[67,25] width:24 height:24  images:#(load_icon() , undefined, 10, 2, 7, 1, 1)   
 checkbutton select_edge_odd_btn "" pos:[111,25] width:24 height:24  images:#(load_icon() , undefined, 10, 4, 9, 1, 1)   
 GroupBox grp30 "间隔选择" pos:[2,87] width:155 height:83
 
 
 checkbutton select_edge_ring_btn1 "" pos:[34,110] width:24 height:24  images:#(load_icon() , undefined, 10, 2, 7, 1, 1) 
 checkbutton select_edge_loop_btn2 "" pos:[93,110] width:24 height:24  images:#(load_icon() , undefined, 10, 4, 9, 1, 1)   
 
 on select_vertex_odd_btn  changed state do
 (
  
   if state == on then
   (
    select_vertex_even_btn.checked=false
    select_edge_odd_btn.checked=false
   
   
   )----end if state
  
 )----end on

     on select_vertex_even_btn  changed state do
 (
  
   if state == on then
   (
    select_vertex_odd_btn.checked=false
    select_edge_odd_btn.checked=false
   
   
   )----end if state
  
 )----end on
     
    on select_edge_odd_btn  changed state do
 (
  
   if state == on then
   (
    select_vertex_odd_btn.checked=false
    select_vertex_even_btn.checked=false
   
   
   )----end if state
  
 )----end on
 
    on select_edge_ring_btn1  changed state do
 (
  
   if state == on then
   (
    select_edge_loop_btn2.checked=false
   -- select_vertex_even_btn.checked=false
   
   
   )----end if state
  
 )----end on
 
  on select_edge_loop_btn2  changed state do
 (
  
   if state == on then
   (
    select_edge_ring_btn1.checked=false
   -- select_vertex_even_btn.checked=false
   
   
   )----end if state
  
 )----end on
 ----------====================================================分类选择
 on select_edge_even_btn pressed do
 (
  case of
  (
   (select_vertex_odd_btn.checked==true):
   (
    try (  odd_numbers_even_numbers $ "select_vertex" "odd" guolu_spn.value )catch ()
    
   )---end ()

   (select_vertex_even_btn.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try ( odd_numbers_even_numbers $ "select_edge" "odd" guolu_spn.value )catch ()
   )---end ()

   (select_edge_odd_btn.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try (  odd_numbers_even_numbers $ "select_polygon" "odd" guolu_spn.value )catch ()
   )---end ()

  )----end case of
  
  
 )---end on select_edge
 on select_face_odd_btn pressed do
 (
  case of
  (
   (select_vertex_odd_btn.checked==true):
   (
    try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    
   )---end ()

   (select_vertex_even_btn.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try ( odd_numbers_even_numbers $ "select_edge" "even" guolu_spn.value )catch ()
   )---end ()

   (select_edge_odd_btn.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try (  odd_numbers_even_numbers $ "select_polygon" "even" guolu_spn.value )catch ()
   )---end ()

  )----end case of
  
  
 )---end on select_edge
 
 on select_edge_ring_btn pressed do
 (
  case of
  (
   (select_edge_ring_btn1.checked==true):
   (
    try (  max_2011_mode_style $ "select_edge" "ring" max_2011_spn.value )catch ()
    
   )---end ()

   (select_edge_loop_btn2.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try (  max_2011_mode_style $ "select_polygon" "ring" max_2011_spn.value )catch ()
   )---end ()
  )
  
  
  
 )---end on
 
  on select_edge_loop_btn pressed do
 (
  case of
  (
   (select_edge_ring_btn1.checked==true):
   (
    try (  max_2011_mode_style $ "select_edge" "loop" max_2011_spn.value )catch ()
    
   )---end ()

   (select_edge_loop_btn2.checked==true):
   (
    --try (  odd_numbers_even_numbers $ "select_vertex" "even" guolu_spn.value )catch ()
    try (  max_2011_mode_style $ "select_polygon" "loop" max_2011_spn.value )catch ()
   )---end ()
  )
  
  
  
 )---end on

 
 
 
)
----****************************************************************************


-----还有一个就是随机的选择面熟
----这个思路相对明确一些,判断是不是 poly mrsh 到面层级
---2. 收集所有面的数组。这里有两种情况
 ---3我要随机的选择100 个面,还有就是我要递增的选择100 个面。
 ---我是这样随即。random 1 到面熟。 选择多少个进行多少次,加到数组
 ----并且我们还不能叫数组有重复的。就好了。
 ---在下面由一个“变体”的功能,其实不错。我是这样考虑的。
 ---1.知道poly的因素数,判断面数所在因素数,这样在选择相应的因素数, 这里面可能有多面在通一个因素上
 ---2.这样这时要叫因素具有唯一性就好。
--下面开始写随即函数。
--非常重要的一点。随即函数 在在poly层进行。并且是在基层处理。在这个基层之上
-- 随机的  点  线  面   。 就是说  如果我预先选择了  点 线 面 就是在选择的基层上进行随机的处理,如果没有就是全局的处理。
-- 其实还有一点就是因素的随机。这个在后来也是很重要的。这个要记住。
--在选择里我加入10 % 处理,但是一定到时候要转整数。因为边面点,不存在. 几的问题。
 fn poly_random_type  input_poly  type  count_t  percentage = --函数是 随机选择因素的。type 是因素的种类 (暂时不考虑因素的最后一个)
  --count_t 按数量 percentage 按百分比。 input_poly 输入者
 (
    case of ---这个是我的手动的处理。所以这里面我只列举3 中情况进行处理。
  (

  (type == "vertex"): (
   
   local  vertes_count__ =#()
   ------这里面由两种选择,数量的选择 ,还有就是 % 的选择,到最后我倒ui中要最一个事件
   ----当count_t percentage 同时不为零,报错机制触发,当 count_t ==0 那么 percentage==10 当percentage ==0 那么count_t ==1
   ----选择好选择类型在,处理,我是当前选择了。还是没有选择,进行处理。
   ---先做数量的选择
   if  percentage ==0 and count_t ==0 then return false
   if  percentage !=0 and count_t !=0 then return false  ---这样的报错机制就好了。
    
    if percentage ==0 and count_t !=0 then -----拾取个数的情况。
    (
      local Back_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumVerts input_poly
     ---全局顶点数,和当前选择的数组。
     if count_t >total_Verts_array then count_t =total_Verts_array ------保证输入的个数不超标
      Back_Verts_array = polyop.getVertSelection  input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     (
      for i in 1 to count_t do
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
     
     
     )---end back
      if( Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      Back_Verts_array=(Back_Verts_array as array) --这中方式其实就是临时的被改。
     
      if count_t > Back_Verts_array.count then count_t =Back_Verts_array.count  ------保证输入的个数不超标
      for i in 1 to count_t do --同是给输入的数量一个定义
      (
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
 
      )---end for  i in 1 to count_t ..
 
     )----end if BACK

    
    )---end if percenntage
    if percentage !=0 and count_t ==0 then  ----%比的情况,这个很好。
    (
     ---% 情况其实可以和之前的一模一样,也是吧% 的数组线算出来。
     local Back_Verts_array ,total_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumVerts input_poly
     ---全局顶点数,和当前选择的数组。
     /*
       percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
      */
      Back_Verts_array = polyop.getVertSelection  input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     ( 
      percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
     
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
     )---end back
     -----------------------2011.4.22 过了一天接着写
     if (Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      percentage_count=  ((Back_Verts_array as array) .count) *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >((Back_Verts_array as array) .count) then percentage_count =((Back_Verts_array as array) .count) ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
      (
       ---这里要加入数组唯一化机制
      -- random_count=  random 1 total_Verts_array
       Back_Verts_array=Back_Verts_array as array  ---
       ---2011.4.22 测试不行是,是忘了转会数组,这个很重要。
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
  
     )----end back

    
    )--end if percentage

   
   
    polyop.setVertSelection   input_poly  vertes_count__
    nodeInvalRect input_poly
  )--end ()

  (type == "edge"): (
   
   local  vertes_count__ =#()
   ------这里面由两种选择,数量的选择 ,还有就是 % 的选择,到最后我倒ui中要最一个事件
   ----当count_t percentage 同时不为零,报错机制触发,当 count_t ==0 那么 percentage==10 当percentage ==0 那么count_t ==1
   ----选择好选择类型在,处理,我是当前选择了。还是没有选择,进行处理。
   ---先做数量的选择
   if  percentage ==0 and count_t ==0 then return false
   if  percentage !=0 and count_t !=0 then return false  ---这样的报错机制就好了。
    
    if percentage ==0 and count_t !=0 then -----拾取个数的情况。
    (
      local Back_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumEdges  input_poly
     ---全局顶点数,和当前选择的数组。
     if count_t >total_Verts_array then count_t =total_Verts_array ------保证输入的个数不超标
      Back_Verts_array = polyop.getEdgeSelection   input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     (
      for i in 1 to count_t do
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
     
     
     )---end back
      if( Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      Back_Verts_array=(Back_Verts_array as array) --这中方式其实就是临时的被改。
     
      if count_t > Back_Verts_array.count then count_t =Back_Verts_array.count  ------保证输入的个数不超标
      for i in 1 to count_t do --同是给输入的数量一个定义
      (
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
 
      )---end for  i in 1 to count_t ..
 
     )----end if BACK

    
    )---end if percenntage
    if percentage !=0 and count_t ==0 then  ----%比的情况,这个很好。
    (
     ---% 情况其实可以和之前的一模一样,也是吧% 的数组线算出来。
     local Back_Verts_array ,total_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumEdges   input_poly
     ---全局顶点数,和当前选择的数组。
     /*
       percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
      */
      Back_Verts_array = polyop.getEdgeSelection   input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     ( 
      percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
     
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
     )---end back
     -----------------------2011.4.22 过了一天接着写
     if (Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      percentage_count=  ((Back_Verts_array as array) .count) *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >((Back_Verts_array as array) .count) then percentage_count =((Back_Verts_array as array) .count) ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
      (
       ---这里要加入数组唯一化机制
      -- random_count=  random 1 total_Verts_array
       Back_Verts_array=Back_Verts_array as array  ---
       ---2011.4.22 测试不行是,是忘了转会数组,这个很重要。
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
  
     )----end back

    
    )--end if percentage

   
   
    polyop.setEdgeSelection   input_poly  vertes_count__
    nodeInvalRect input_poly
   
   
  )----end ()

  (type == "polygon"):(
   
   local  vertes_count__ =#()
   ------这里面由两种选择,数量的选择 ,还有就是 % 的选择,到最后我倒ui中要最一个事件
   ----当count_t percentage 同时不为零,报错机制触发,当 count_t ==0 那么 percentage==10 当percentage ==0 那么count_t ==1
   ----选择好选择类型在,处理,我是当前选择了。还是没有选择,进行处理。
   ---先做数量的选择
   if  percentage ==0 and count_t ==0 then return false
   if  percentage !=0 and count_t !=0 then return false  ---这样的报错机制就好了。
    
    if percentage ==0 and count_t !=0 then -----拾取个数的情况。
    (
      local Back_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumFaces  input_poly
     ---全局顶点数,和当前选择的数组。
     if count_t >total_Verts_array then count_t =total_Verts_array ------保证输入的个数不超标
      Back_Verts_array = polyop.getFaceSelection   input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     (
      for i in 1 to count_t do
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
     
     
     )---end back
      if( Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      Back_Verts_array=(Back_Verts_array as array) --这中方式其实就是临时的被改。
     
      if count_t > Back_Verts_array.count then count_t =Back_Verts_array.count  ------保证输入的个数不超标
      for i in 1 to count_t do --同是给输入的数量一个定义
      (
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
 
      )---end for  i in 1 to count_t ..
 
     )----end if BACK

    
    )---end if percenntage
    if percentage !=0 and count_t ==0 then  ----%比的情况,这个很好。
    (
     ---% 情况其实可以和之前的一模一样,也是吧% 的数组线算出来。
     local Back_Verts_array ,total_Verts_array
    ---查看当前选择的点,分两种情况进行。数组为空与不为空,分为全局与局部的关系。
     total_Verts_array = polyop.getNumFaces  input_poly
     ---全局顶点数,和当前选择的数组。
     /*
       percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
      */
      Back_Verts_array = polyop.getFaceSelection   input_poly
                    
     if (Back_Verts_array as array) .count ==0 then --- 全局选择
     ( 
      percentage_count=  total_Verts_array *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >total_Verts_array then percentage_count =total_Verts_array ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
     
      (
       ---这里要加入数组唯一化机制
       random_count=  random 1 total_Verts_array
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
     )---end back
     -----------------------2011.4.22 过了一天接着写
     if (Back_Verts_array as array) .count !=0 then --- 全局选择
     (
      percentage_count=  ((Back_Verts_array as array) .count) *percentage /100
       percentage_count = percentage_count as integer
     if percentage_count >((Back_Verts_array as array) .count) then percentage_count =((Back_Verts_array as array) .count) ------保证输入的个数不超标
     
      local true_tt =true
       while ( true_tt)do
      (
      --for i in 1 to total_Verts_array do --因为我在上面进行了数量的把控 所以这里面是在真个中循环
     ---我明白了这里就不用加循环了。 while本身就是循环 所以这里就这样就慢死了 
      (
       ---这里要加入数组唯一化机制
      -- random_count=  random 1 total_Verts_array
       Back_Verts_array=Back_Verts_array as array  ---
       ---2011.4.22 测试不行是,是忘了转会数组,这个很重要。
       random_count=   Back_Verts_array [ (random 1 Back_Verts_array.count )]----局部内的点数。
       ---这里面我要说下,因为是100 % 但是由于随机 经常取一样的值。就是100% 的点中 在跑去相同,所以会出现 不满的情况。
       --我应该最死循环, 知道数组中的数量 符合他的 % 分数。
      
       if  findItem vertes_count__  random_count ==0 then
      (
       ---因为我没有循环点。所以不用加入 undefined 机制。 在询问面 返回点的函数时,有时面本来是多了,但是在循环面找点是 就是
       ---undefined  这个自己一定要记住。
       append vertes_count__ random_count
      )---end if finditem
      
      )---end for total
      if (vertes_count__.count ==percentage_count ) then
      (
       true_tt=false
      )
     
        )---end while
  
     )----end back

    
    )--end if percentage

   
   
   polyop.setFaceSelection   input_poly  vertes_count__
    nodeInvalRect input_poly
   
  )


  )--- end  case of

 
 )----end fn


---上面的元素基本是完成了。但是我是想找到基于poly的因素的操作。因素里面我就想是基于百分比进行操作。


 try(cui.UnRegisterDialogBar gt_random_select)catch()-----这个是法则。
try (DestroyDialog gt_random_select )catch()
 
rollout gt_random_select "随机的因素选择" width:160 height:133
(
  fn  load_icon  = (
  a=openbitmap  ((GetDir #ui)+ "\\Icons\\"  + "EditMesh_24i.bmp")-- 位图的打开
  return a
  )
 spinner random_num_spn "随机数:" pos:[19,3] width:109 height:16 range:[0,1e+008,0] type:#integer
 spinner random_percentage_spn "随机%:" pos:[19,24] width:110 height:16 range:[0,100,0] type:#integer
 button vertex_random_btn "点" pos:[19,51] width:24 height:24  images:#(load_icon() , undefined, 10, 1, 6, 1, 1)
 button edge_random_btn "边" pos:[64,51] width:24 height:24   images:#(load_icon() , undefined, 10, 2, 7, 1, 1)
 button face_random_btn "面" pos:[109,51] width:24 height:24   images:#(load_icon() , undefined, 10, 4, 9, 1, 1)
 fn random_m =
 (
  if random_num_spn .value==0 and random_percentage_spn.value ==0 then
  (
   messagebox "随机数和随机% 数,不能同时为零。也不能同时不为零。"title:"永超编写"
  )---end if
  if random_num_spn .value!=0 and random_percentage_spn.value !=0 then
  (
   messagebox "随机数和随机% 数,不能同时为零。也不能同时不为零。"title:"永超编写"
  )---end if
  
 )
 on vertex_random_btn pressed do
 (
  random_m()
  poly_random_type $ "vertex" random_num_spn .value   random_percentage_spn.value
  
 )---end on
  on edge_random_btn pressed do
 (
  random_m()
  poly_random_type $ "edge" random_num_spn .value   random_percentage_spn.value
  
 )---end on
   on face_random_btn pressed do
 (
  random_m()
  poly_random_type $ "polygon" random_num_spn .value   random_percentage_spn.value
  
 )---end on
 
 
 
)

 try(cui.UnRegisterDialogBar gt_mode_tatul)catch()-----这个是法则。
---************************************
 try (closerolloutfloater gt_mode_tatul ) catch ()
  gt_mode_tatul = newrolloutfloater  "2011.4左右(建模)"  160 800   1000 0  --- 这里的构成方式。
   addrollout  gt_mode_big  gt_mode_tatul
    addrollout  transPivot    gt_mode_tatul
    addrollout  gt_up_down_select    gt_mode_tatul
          addrollout  gt_element__    gt_mode_tatul
            addrollout  gt_random_select    gt_mode_tatul

  --createdialog gt_mode_tatul ---这里我加如就是生产 明白?????

cui.RegisterDialogBar gt_mode_tatul style:#(#cui_dock_left,#cui_dock_right, #cui_floatable)
cui.DockDialogBar gt_mode_tatul #cui_dock_right

posted on 2011-04-25 14:00  盖天00  阅读(251)  评论(0编辑  收藏  举报

导航