Home My Page Projects Code Snippets Project Openings 3D graphics for Standard ML
Summary Activity SCM

SCM Repository

[sml3d] Diff of /trunk/sml3d/src/particles/compiler/translate.sml
ViewVC logotype

Diff of /trunk/sml3d/src/particles/compiler/translate.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1074, Tue Jan 25 01:14:34 2011 UTC revision 1091, Mon Feb 14 20:49:21 2011 UTC
# Line 26  Line 26 
26          size : IR.var,          (* float *)          size : IR.var,          (* float *)
27          ttl : IR.var,           (* float *)          ttl : IR.var,           (* float *)
28          color : IR.var,         (* vec3 (NOTE: should be vector4) *)          color : IR.var,         (* vec3 (NOTE: should be vector4) *)
29          rot : IR.var,           (* float *)        user : IR.var list
         pos2 : IR.var,          (* vec3 *)  
         dummy : IR.var  
30        }        }
31    
32    (* special PSV global variables *)    (* special PSV global variables *)
# Line 37  Line 35 
35    (* constants *)    (* constants *)
36      val pi = 3.14159265358979      val pi = 3.14159265358979
37    
38    (* dummy placeholder *)      fun constructUserDefs([]) = []
39      fun dummy (state, k) =        | constructUserDefs(IR.V{id, ...} :: users) =
40            IR.mkPRIM(            (IR.USER_DEF id) :: constructUserDefs(users)
             IR.newLocal(  
               "temp",  
               IR.T_BOOL,  
               (IR.COPY, [IR.newConst("c", IR.C_BOOL false)])  
             ),  
             IR.COPY,  
             [IR.newConst("c", IR.C_BOOL false)],  
             k state  
           )  
41    
42        fun userVarsFromState(PS{user, ...}) = user
43        fun userVarsFromEmit(P.EMIT{...}) = []
44    
45      fun retState s = let      fun retState s = let
46        val PS{pos, vel, size, ttl, color, rot, pos2, dummy} = s        val PS{pos, vel, size, ttl, color, user} = s
47       in       in
48        IR.mkRETURN (        IR.mkRETURN (
49          [pos, vel, size, ttl, color, rot, pos2, dummy],          [pos, vel, size, ttl, color] @ user,
50          [IR.POS, IR.VEL, IR.SZ, IR.TTL, IR.COLOR, IR.ROT, IR.POS2, IR.DUMMY]          [IR.POS, IR.VEL, IR.SZ, IR.TTL, IR.COLOR] @ constructUserDefs(user)
51        )        )
52       end       end
53    
# Line 71  Line 62 
62      fun insert (TE(blks, env), x, x') = TE(blks, PSV.Map.insert (env, x, x'))      fun insert (TE(blks, env), x, x') = TE(blks, PSV.Map.insert (env, x, x'))
63    
64    (* create a block that implements the given continuation *)    (* create a block that implements the given continuation *)
65      fun newBlock (TE(blks, _), k : particle_state -> IR.stmt) = let  
66        fun createUserVarCopies( [ ], _ ) = [ ]
67          | createUserVarCopies( IR.V{varType, ...} :: vars, i) =
68          IR.newParam ("ps_user" ^ (Int.toString i), varType) :: (createUserVarCopies(vars, i+1))
69    
70        fun newBlock (TE(blks, _), userVars, k : particle_state -> IR.stmt) = let
71            val pos = IR.newParam ("ps_pos", IR.T_VEC)            val pos = IR.newParam ("ps_pos", IR.T_VEC)
72            val vel = IR.newParam ("ps_vel", IR.T_VEC)            val vel = IR.newParam ("ps_vel", IR.T_VEC)
73            val size = IR.newParam ("ps_size", IR.T_FLOAT)            val size = IR.newParam ("ps_size", IR.T_FLOAT)
74            val ttl = IR.newParam ("ps_ttl", IR.T_FLOAT)            val ttl = IR.newParam ("ps_ttl", IR.T_FLOAT)
75            val color = IR.newParam ("ps_color", IR.T_VEC)            val color = IR.newParam ("ps_color", IR.T_VEC)
76            val rot = IR.newParam("ps_rot", IR.T_FLOAT)            val userVarCopies = createUserVarCopies(userVars, 0)
77            val dummy = IR.newParam ("ps_dummy", IR.T_FLOAT)            val state = PS{pos=pos, vel=vel, size=size, ttl=ttl, color=color, user=userVarCopies}
78            val pos2 = IR.newParam ("ps_pos2", IR.T_VEC)            val blk = IR.newBlock ([pos, vel, size, ttl, color] @ userVarCopies, k state)
           val state = PS{pos=pos, vel=vel, size=size, ttl=ttl, color=color, rot=rot, pos2=pos2, dummy=dummy}  
           val blk = IR.newBlock ([pos, vel, size, ttl, color, rot, pos2, dummy], k state)  
79            in            in
80              blks := blk :: !blks;              blks := blk :: !blks;
81              blk              blk
82            end            end
83    
84          fun newBlockWithArgs (TE(blks, _), args, k : particle_state -> IR.stmt) = let          fun newBlockWithArgs (TE(blks, _), userVars, args, k : particle_state -> IR.stmt) = let
85            val pos = IR.newParam ("ps_pos", IR.T_VEC)            val pos = IR.newParam ("ps_pos", IR.T_VEC)
86            val vel = IR.newParam ("ps_vel", IR.T_VEC)            val vel = IR.newParam ("ps_vel", IR.T_VEC)
87            val size = IR.newParam ("ps_size", IR.T_FLOAT)            val size = IR.newParam ("ps_size", IR.T_FLOAT)
88            val ttl = IR.newParam ("ps_ttl", IR.T_FLOAT)            val ttl = IR.newParam ("ps_ttl", IR.T_FLOAT)
89            val color = IR.newParam ("ps_color", IR.T_VEC)            val color = IR.newParam ("ps_color", IR.T_VEC)
90            val rot = IR.newParam("ps_rot", IR.T_FLOAT)            val rot = IR.newParam("ps_rot", IR.T_FLOAT)
91            val dummy = IR.newParam ("ps_dummy", IR.T_FLOAT)            val userVarCopies = createUserVarCopies(userVars, 0)
92            val pos2 = IR.newParam ("ps_pos2", IR.T_VEC)            val state = PS{pos=pos, vel=vel, size=size, ttl=ttl, color=color, user = userVarCopies}
93            val state = PS{pos=pos, vel=vel, size=size, ttl=ttl, color=color, rot=rot, pos2=pos2, dummy=dummy}            val blk = IR.newBlock (List.concat[[pos, vel, size, ttl, color], userVarCopies, args], k state)
           val blk = IR.newBlock ([pos, vel, size, ttl, color, rot, pos2, dummy] @ args, k state)  
94            in            in
95              blks := blk :: !blks;              blks := blk :: !blks;
96              blk              blk
97            end            end
98    
99      fun goto (PS{pos, vel, size, ttl, color, rot, pos2, dummy}, blk) =      fun goto (PS{pos, vel, size, ttl, color, user}, blk) =
100            IR.mkGOTO(blk, [pos, vel, size, ttl, color, rot, pos2, dummy])            IR.mkGOTO(blk, [pos, vel, size, ttl, color] @ user)
101    
102          fun gotoWithArgs(PS{pos, vel, size, ttl, color, rot, pos2, dummy}, args, blk) =          fun gotoWithArgs(PS{pos, vel, size, ttl, color, user}, args, blk) =
103            IR.mkGOTO(blk, [pos, vel, size, ttl, color, rot, pos2, dummy] @ args)            IR.mkGOTO(blk, List.concat[[pos, vel, size, ttl, color], user, args])
104    
105      fun letPRIM (x, ty, p, args, body) = let      fun letPRIM (x, ty, p, args, body) = let
106            val x' = IR.newLocal(x, ty, (p, args))            val x' = IR.newLocal(x, ty, (p, args))
# Line 357  Line 350 
350        | generate (Dblob{c, stddev}) = Vec3f.unpack c        | generate (Dblob{c, stddev}) = Vec3f.unpack c
351            *)            *)
352    
   
353    (* This function takes an IR boolean, its environment, a particle state, domain,    (* This function takes an IR boolean, its environment, a particle state, domain,
354     * and continuation.     * and continuation.
355     *     *
# Line 508  Line 500 
500                     size = newSize,                     size = newSize,
501                     ttl = newIsDead,                     ttl = newIsDead,
502                     color = newCol,                     color = newCol,
503                     rot = IR.newConst("ps_rot", IR.C_FLOAT 0.0),                     user = []})
                    pos2 = IR.newConst("ps_pos2", IR.C_VEC {x=0.0, y=0.0, z=0.0}),  
                    dummy = IR.newConst("ps_dummy", IR.C_FLOAT 0.01)})  
504              )))))              )))))
505    
506      (* Find the normal at the given position of the particle for the specified      (* Find the normal at the given position of the particle for the specified
# Line 519  Line 509 
509       *)       *)
510      fun normAtPoint(retNorm, d, env, state, k : IR.var -> particle_state -> IR.stmt) = let      fun normAtPoint(retNorm, d, env, state, k : IR.var -> particle_state -> IR.stmt) = let
511        val newNorm = IR.newParam("n", IR.T_VEC)        val newNorm = IR.newParam("n", IR.T_VEC)
512        val nextBlk = newBlockWithArgs(env, [newNorm], k(newNorm))        val nextBlk = newBlockWithArgs(env, userVarsFromState(state), [newNorm], k(newNorm))
513        val PS{pos, ...} = state        val PS{pos, ...} = state
514       in       in
515        (case d        (case d
# Line 554  Line 544 
544    
545          fun trEmitter(emit, env, state, k : particle_state -> IR.stmt) = let          fun trEmitter(emit, env, state, k : particle_state -> IR.stmt) = let
546    
547            val PS{ttl, ...} = state            val PS{ttl, user, ...} = state
548            val P.EMIT{range, szDomain, posDomain, velDomain, colDomain, ...} = emit            val P.EMIT{range, szDomain, posDomain, velDomain, colDomain, ...} = emit
549            val (rDom, rDist) = range            val (rDom, rDist) = range
550            val blk = newBlock (env, k)            val blk = newBlock (env, user, k)
551           in           in
552            letPRIM("isDead", IR.T_BOOL, IR.GT, [IR.newConst("small", IR.C_FLOAT 0.1), ttl], fn isDead =>            letPRIM("isDead", IR.T_BOOL, IR.GT, [IR.newConst("small", IR.C_FLOAT 0.1), ttl], fn isDead =>
553        IR.mkIF(isDead,        IR.mkIF(isDead,
# Line 589  Line 579 
579           end           end
580    
581      fun trAct (action, env, state, k : particle_state -> IR.stmt) = let      fun trAct (action, env, state, k : particle_state -> IR.stmt) = let
582            val PS{pos, vel, size, ttl, color, rot, pos2, dummy} = state            val PS{pos, vel, size, ttl, color, user} = state
583            in            in
584              case action              case action
585               of P.BOUNCE{friction, resilience, cutoff, d} => let               of P.BOUNCE{friction, resilience, cutoff, d} => let
586                    val blk = newBlock (env, k)                    val blk = newBlock (env, user, k)
587                    val negOne = IR.newConst("negOne", IR.C_FLOAT ~1.0)                    val negOne = IR.newConst("negOne", IR.C_FLOAT ~1.0)
588                    in                    in
589                      letPRIM("vs", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), vel], fn velScale =>                      letPRIM("vs", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), vel], fn velScale =>
# Line 605  Line 595 
595                      IR.mkIF(shouldBounce,                      IR.mkIF(shouldBounce,
596                        (*then*)                        (*then*)
597                          normAtPoint("n", d, env, state, fn normAtD => fn state' => let                          normAtPoint("n", d, env, state, fn normAtD => fn state' => let
598                 val PS{pos=nextPos, vel=nextVel, size=nextSize, ttl=nextIsDead, color=nextColor, rot=nextRot, pos2=nextPos2, dummy=nextDummy} = state'                 val PS{pos=nextPos, vel=nextVel, size=nextSize, ttl=nextIsDead, color=nextColor, user=nextUser} = state'
599                            in                            in
600                             letPRIM("negVel", IR.T_VEC, IR.SCALE, [negOne, nextVel], fn negVel =>                             letPRIM("negVel", IR.T_VEC, IR.SCALE, [negOne, nextVel], fn negVel =>
601                             letPRIM("dnv", IR.T_FLOAT, IR.DOT, [negVel, normAtD], fn dotNegVel =>                             letPRIM("dnv", IR.T_FLOAT, IR.DOT, [negVel, normAtD], fn dotNegVel =>
# Line 624  Line 614 
614                               letPRIM("f", IR.T_FLOAT, IR.MULT, [negOne, frictInv], fn modFrict =>                               letPRIM("f", IR.T_FLOAT, IR.MULT, [negOne, frictInv], fn modFrict =>
615                               letPRIM("fTang", IR.T_VEC, IR.SCALE, [modFrict, tang], fn frictTang =>                               letPRIM("fTang", IR.T_VEC, IR.SCALE, [modFrict, tang], fn frictTang =>
616                               letPRIM("newVel", IR.T_VEC, IR.ADD_VEC, [frictTang, resNorm], fn newVel =>                               letPRIM("newVel", IR.T_VEC, IR.ADD_VEC, [frictTang, resNorm], fn newVel =>
617                                goto(PS{pos=nextPos, vel=newVel, size=nextSize, ttl=nextIsDead, color=nextColor, rot=nextRot, pos2=nextPos2, dummy=nextDummy}, blk)                                goto(PS{pos=nextPos, vel=newVel, size=nextSize, ttl=nextIsDead, color=nextColor, user=nextUser}, blk)
618                              )))),                              )))),
619                               (*else*)                               (*else*)
620                               letPRIM("fTang", IR.T_VEC, IR.SCALE, [negOne, tang], fn frictTang =>                               letPRIM("fTang", IR.T_VEC, IR.SCALE, [negOne, tang], fn frictTang =>
621                               letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [frictTang, resNorm], fn newVel =>                               letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [frictTang, resNorm], fn newVel =>
622                                goto(PS{pos=nextPos, vel=newVel, size=nextSize, ttl=nextIsDead, color=nextColor, rot=nextRot, pos2=nextPos2, dummy=nextDummy}, blk)                                goto(PS{pos=nextPos, vel=newVel, size=nextSize, ttl=nextIsDead, color=nextColor, user=nextUser}, blk)
623                               ))                               ))
624                           )))))))))                           )))))))))
625                           end                           end
# Line 641  Line 631 
631                | P.ACCEL dir =>                | P.ACCEL dir =>
632                      letPRIM("scaledVec", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), psvToIRVar(env, dir)], fn theScale =>                      letPRIM("scaledVec", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), psvToIRVar(env, dir)], fn theScale =>
633                      letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [theScale, vel], fn newVel =>                      letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [theScale, vel], fn newVel =>
634                        k(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, rot=rot, pos2=pos2, dummy=dummy})))                        k(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, user = user})))
635    
636                | P.MOVE =>                | P.MOVE =>
637                  letPRIM("scaledVec", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), vel], fn theScale =>                  letPRIM("scaledVec", IR.T_VEC, IR.SCALE, [psvToIRVar(env, PSV.timeStep), vel], fn theScale =>
638                      letPRIM("ps_pos", IR.T_VEC, IR.ADD_VEC, [theScale, pos], fn newPos =>                      letPRIM("ps_pos", IR.T_VEC, IR.ADD_VEC, [theScale, pos], fn newPos =>
639                        k(PS{pos = newPos, vel = vel, size = size, ttl = ttl, color = color, rot=rot, pos2=pos2, dummy=dummy})))                        k(PS{pos = newPos, vel = vel, size = size, ttl = ttl, color = color, user = user})))
640                (*  
               | P.SINK({d, kill_inside}) =>  
                     mkWithinVar("isWithin", env, state, d, fn withinVal =>  
                     mkXOR ("shouldNotKill", withinVal, psvToIRVar(env, kill_inside),  
                       fn shouldNotKill =>  
                     letPRIM("shouldKill", IR.T_BOOL, IR.NOT, [shouldNotKill], fn shouldKill =>  
                     letPRIM("isReallyDead", IR.T_BOOL, IR.OR, [shouldKill, ttl], fn isReallyDead =>  
                     k(PS{pos = pos, vel = vel, size = size, ttl = isReallyDead, color = color})  
                         ))))  
               *)  
641                | P.ORBITPOINT {center, mag, maxRad} => let                | P.ORBITPOINT {center, mag, maxRad} => let
642                    val blk = newBlock (env, k)                    val blk = newBlock (env, user, k)
643                   in                   in
644                    letPRIM("toCenter", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, center), pos], fn toCenter =>                    letPRIM("toCenter", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, center), pos], fn toCenter =>
645                    letPRIM("dist", IR.T_FLOAT, IR.LEN, [toCenter], fn dist =>                    letPRIM("dist", IR.T_FLOAT, IR.LEN, [toCenter], fn dist =>
# Line 673  Line 654 
654                  letPRIM("totalMag", IR.T_FLOAT, IR.MULT, [gravityMag, psvToIRVar(env, PSV.timeStep)], fn totMag =>                  letPRIM("totalMag", IR.T_FLOAT, IR.MULT, [gravityMag, psvToIRVar(env, PSV.timeStep)], fn totMag =>
655                  letPRIM("acc", IR.T_VEC, IR.SCALE, [totMag, toCenter], fn acc =>                  letPRIM("acc", IR.T_VEC, IR.SCALE, [totMag, toCenter], fn acc =>
656                  letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [vel, acc], fn newVel =>                  letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [vel, acc], fn newVel =>
657                  goto(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, rot=rot, pos2=pos2, dummy=dummy}, blk)                  goto(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, user=user}, blk)
658                    ))))))))))                    ))))))))))
659                   end                   end
660    
661    
662                | P.ORBITLINESEG {endp1, endp2, maxRad, mag} => let                | P.ORBITLINESEG {endp1, endp2, maxRad, mag} => let
663                    val blk = newBlock (env, k)                    val blk = newBlock (env, user, k)
664                  in                  in
665                  letPRIM("subVec", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, endp2), psvToIRVar(env, endp1)], fn subVec =>                  letPRIM("subVec", IR.T_VEC, IR.SUB_VEC, [psvToIRVar(env, endp2), psvToIRVar(env, endp1)], fn subVec =>
666                  letPRIM("vecToEndP", IR.T_VEC, IR.SUB_VEC, [pos, psvToIRVar(env, endp1)], fn vecToEndP =>                  letPRIM("vecToEndP", IR.T_VEC, IR.SUB_VEC, [pos, psvToIRVar(env, endp1)], fn vecToEndP =>
# Line 702  Line 683 
683                    letPRIM("accVec", IR.T_VEC, IR.SUB_VEC, [closestP, pos], fn accVec =>                    letPRIM("accVec", IR.T_VEC, IR.SUB_VEC, [closestP, pos], fn accVec =>
684                    letPRIM("acc", IR.T_VEC, IR.SCALE, [totMag, accVec], fn acc =>                    letPRIM("acc", IR.T_VEC, IR.SCALE, [totMag, accVec], fn acc =>
685                    letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [vel, acc], fn newVel =>                    letPRIM("ps_vel", IR.T_VEC, IR.ADD_VEC, [vel, acc], fn newVel =>
686                    goto(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, rot=rot, pos2=pos2, dummy=dummy}, blk)                    goto(PS{pos = pos, vel = newVel, size = size, ttl = ttl, color = color, user=user}, blk)
687                    )))))))                    )))))))
688                  )))))))))))                  )))))))))))
689                  end                  end
# Line 750  Line 731 
731                    | act :: rest => trAct(act, env, state, evalActs f (P.SEQ(rest) :: psal))                    | act :: rest => trAct(act, env, state, evalActs f (P.SEQ(rest) :: psal))
732                  (* end case *))                  (* end case *))
733                 | P.PRED(pred as P.PR{thenstmt=t, elsestmt=e, ...}) => let                 | P.PRED(pred as P.PR{thenstmt=t, elsestmt=e, ...}) => let
734                     val cblk = newBlock(env, evalActs f psal)                  val cblk = newBlock(env, userVarsFromState(state), evalActs f psal)
735                     fun trPredActs [] state' = goto(state', cblk)                     fun trPredActs [] state' = goto(state', cblk)
736                       | trPredActs _ _ = raise Fail "Should never reach here."                       | trPredActs _ _ = raise Fail "Should never reach here."
737                    in                    in
# Line 760  Line 741 
741    
742            (* At the highest level, we want to return when we reach the end of the action list *)            (* At the highest level, we want to return when we reach the end of the action list *)
743            fun trActs [] state = let            fun trActs [] state = let
744                  val PS{pos, vel, size, ttl, color, rot, pos2, dummy} = state                  val PS{pos, vel, size, ttl, color, user} = state
745                  in                  in
746                    IR.mkRETURN (                    IR.mkRETURN (
747                      [ pos, vel, size, ttl, color, rot, pos2, dummy ],                      [ pos, vel, size, ttl, color ] @ user,
748                      [IR.POS, IR.VEL, IR.SZ, IR.TTL, IR.COLOR, IR.ROT, IR.POS2, IR.DUMMY]                      [IR.POS, IR.VEL, IR.SZ, IR.TTL, IR.COLOR ] @ (constructUserDefs(user))
749                    )                    )
750                  end (* trActs *)                  end
751              | trActs _ _ = raise Fail "Should never reach here"              | trActs _ _ = raise Fail "Should never reach here"
752    
753            (* The entry block is the first block of the program, or in other words, the emitter. *)            (* The entry block is the first block of the program, or in other words, the emitter. *)
754            val entryBlock = newBlock (            val entryBlock = newBlock (
755              env,              env,
756                userVarsFromEmit(emit),
757              fn pstate => trEmitter(              fn pstate => trEmitter(
758                emit,                emit,
759                env,                env,

Legend:
Removed from v.1074  
changed lines
  Added in v.1091

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0