Ejemplo n.º 1
0
Archivo: guide.py Proyecto: UIKit0/Gear
    def addObjects(self):

        self.root = self.addRoot()
        self.neck = self.addLoc("neck", self.root)
        self.head = self.addLoc("head", self.neck)
        self.eff = self.addLoc("eff", self.head)

        v0 = vec.linearlyInterpolate(self.root.Kinematics.Global.Transform.Translation, self.neck.Kinematics.Global.Transform.Translation, .333)
        self.tan0 = self.addLoc("tan0", self.root, v0)
        v1 = vec.linearlyInterpolate(self.root.Kinematics.Global.Transform.Translation, self.neck.Kinematics.Global.Transform.Translation, .666)
        self.tan1 = self.addLoc("tan1", self.head, v1)

        self.blade = self.addBlade("blade", self.root, self.tan0)

        centers = [self.root, self.tan0, self.tan1, self.neck]
        self.dispcrv = self.addDispCurve("neck_crv", centers, 3)

        centers = [self.neck, self.head, self.eff]
        self.dispcrv = self.addDispCurve("head_crv", centers, 1)
Ejemplo n.º 2
0
    def addObjects(self):

        self.root = self.addRoot()
        self.neck = self.addLoc("neck", self.root)
        self.head = self.addLoc("head", self.neck)
        self.eff = self.addLoc("eff", self.head)

        v0 = vec.linearlyInterpolate(self.root.Kinematics.Global.Transform.Translation, self.neck.Kinematics.Global.Transform.Translation, .333)
        self.tan0 = self.addLoc("tan0", self.root, v0)
        v1 = vec.linearlyInterpolate(self.root.Kinematics.Global.Transform.Translation, self.neck.Kinematics.Global.Transform.Translation, .666)
        self.tan1 = self.addLoc("tan1", self.neck, v1)

        self.blade = self.addBlade("blade", self.root, self.tan0)

        centers = [self.root, self.tan0, self.tan1, self.neck]
        self.dispcrv = self.addDispCurve("neck_crv", centers, 3)

        centers = [self.neck, self.head, self.eff]
        self.dispcrv = self.addDispCurve("head_crv", centers, 1)
Ejemplo n.º 3
0
    def addObjects(self):

        # Ik Controlers ------------------------------------
        t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.guide.blades["blade"].z, "yx", self.negate)
        self.ik0_ctl = self.addCtl(self.root, "ik0_ctl", t, self.color_ik, "compas", w=self.size)
        par.setKeyableParameters(self.ik0_ctl)
        xsi.SetNeutralPose(self.ik0_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ik0_ctl, ["posx", "roty", "rotz"])
        par.setRotOrder(self.ik0_ctl, "XZY")

        t.SetTranslation(self.guide.apos[1])
        self.ik1_ctl = self.addCtl(self.root, "ik1_ctl", t, self.color_ik, "compas", w=self.size)
        par.setKeyableParameters(self.ik1_ctl)
        xsi.SetNeutralPose(self.ik1_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl, ["posx", "roty", "rotz"])
        par.setRotOrder(self.ik1_ctl, "XZY")

        # Tangent controlers -------------------------------
        t.SetTranslation(vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .33))
        self.tan0_ctl = self.addCtl(self.ik0_ctl, "tan0_ctl", t, self.color_ik, "sphere", w=self.size*.2)
        par.setKeyableParameters(self.tan0_ctl, self.t_params)
        xsi.SetNeutralPose(self.tan0_ctl, c.siTrn)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl, ["posx"])

        t.SetTranslation(vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1], .66))
        self.tan1_ctl = self.addCtl(self.ik1_ctl, "tan1_ctl", t, self.color_ik, "sphere", w=self.size*.2)
        par.setKeyableParameters(self.tan1_ctl, self.t_params)
        xsi.SetNeutralPose(self.tan1_ctl, c.siTrn)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl, ["posx"])

        # Curves -------------------------------------------
        self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], False, 3)
        self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [1]*10*4, False, 3)
        self.addToGroup([self.mst_crv, self.slv_crv], "hidden")

        # Division -----------------------------------------
        # The user only define how many intermediate division he wants.
        # First and last divisions are an obligation.
        parentdiv = self.ik0_ctl
        parentctl = self.ik0_ctl
        self.div_cns = []
        self.fk_ctl = []
        for i in range(self.settings["division"]):

            # References
            div_cns = parentdiv.AddNull(self.getName("%s_cns"%i))
            pri.setNullDisplay(div_cns, 1, self.size*.05, 10, 0, 0, 0, 1, 1, 2)
            self.addToGroup(div_cns, "hidden")

            self.div_cns.append(div_cns)
            parentdiv = div_cns

            # Controlers (First and last one are fake)
            if i in [0, self.settings["division"] - 1]:
                fk_ctl = pri.addNull(parentctl, self.getName("%s_loc"%i), parentctl.Kinematics.Global.Transform, self.size*.05)
                self.addToGroup(fk_ctl, "hidden")
            else:
                fk_ctl = self.addCtl(parentctl, "fk%s_ctl"%(i-1), parentctl.Kinematics.Global.Transform, self.color_fk, "cube", w=self.size*1, h=self.size*.05, d=self.size*1)
                self.addToGroup(fk_ctl, "controlers_01")
                par.addLocalParamToCollection(self.inv_params, fk_ctl, ["posx", "roty", "rotz"])
                par.setRotOrder(fk_ctl, "XZY")

            self.fk_ctl.append(fk_ctl)
            parentctl = fk_ctl

            # Deformers (Shadow)
            self.addShadow(fk_ctl, (i))

        # Connections (Hooks) ------------------------------
        self.cnx0 = pri.addNull(self.root, self.getName("0_cnx"), self.root.Kinematics.Global.Transform, self.size*.2)
        self.cnx1 = pri.addNull(self.root, self.getName("1_cnx"), self.root.Kinematics.Global.Transform, self.size*.2)
        self.addToGroup([self.cnx0, self.cnx1], "hidden")
Ejemplo n.º 4
0
    def addObjects(self):

        self.inter_shd = 1
        self.shd_count = self.inter_shd * 2 + 3
        self.inter_crv = 1
        self.crv_count = self.inter_crv * 2 + 1

        self.npo = []
        self.ctl = []

        self.crv = []
        self.upv = []
        self.ctr = []
        self.off = []
        self.cns_crv = []
        self.loc = []

        self.percentages = []

        for i, name, blade in zip(range(3), ["root", "mid_loc", "end_loc"], ["blade", "mid_blade", "end_blade"]):

            # Path ----------------------------------------
            crv = self.guide.prim["%s_crv"%i].create(self.root, self.getName("%s_crv"%i), None)
            xsi.SetNeutralPose(crv)

            self.crv.append(crv)
            self.addToGroup(crv, "hidden")

            if i == 0:
                y0 = cur.getGlobalPointPosition(0, crv).Y
                y1 = cur.getGlobalPointPosition(crv.ActivePrimitive.Geometry.Points.Count-1, crv).Y

                self.scale = (y1 - y0) * .5

            # Controlers ----------------------------------
            lookat = XSIMath.CreateVector3()
            lookat.Add(self.guide.pos[name], self.guide.blades[blade].x)
            if blade == "end_blade":
                axisPlane = "zx"
                axisNegate =  True
            else:
                axisPlane = "zx"
                axisNegate = False
            t = tra.getTransformLookingAt(self.guide.pos[name], lookat, self.guide.blades[blade].y, axisPlane, axisNegate)
            t.SetScaling(XSIMath.CreateVector3(self.scale, self.scale, self.scale))

            npo = pri.addNull(self.root, self.getName("%s_npo"%i), t, 1)
            pri.setNullDisplay(npo, 0, 1, 4, 0, 0, 0, .15, 2, 0)
            self.addToGroup(npo, "unselectable")

            ctl = self.addCtl(npo, "%s_ctl"%i, t, self.color_ik, "sphere", w=.2)
            xsi.SetNeutralPose(ctl)
            par.setKeyableParameters(ctl, ["posx", "posy", "posz", "rotx", "roty", "rotz", "rotorder", "sclx"])
            # par.addLocalParamToCollection(self.inv_params, ctl, ["posx", "roty", "rotz"]) # to be defined
            # par.setRotOrder(ctl, "XZY") # to be defined

            self.ctl.append(ctl)


            # Up Vector, Center, Offset -------------------
            v = XSIMath.CreateVector3(self.guide.blades[blade].x.X, self.guide.blades[blade].x.Y, self.guide.blades[blade].x.Z)
            v.ScaleInPlace(-self.size)
            v.AddInPlace(self.guide.pos[name])
            upv = pri.addNullFromPos(crv, self.getName("%s_upv")%i, v, self.size*.025)
            ctr = [pri.addNullFromPos(crv, self.getName("%s_%s_ctr"%(i,j)), self.guide.apos[i], self.size*.025) for j in range(3)]
            off = pri.addNullFromPos(ctr[1], self.getName("%s_off")%i, self.guide.apos[i], self.size*.05)

            self.upv.append(upv)
            self.ctr.append(ctr)
            self.off.append(off)
            self.addToGroup(upv, "hidden")
            self.addToGroup(ctr, "hidden")
            self.addToGroup(off, "hidden")

            # Collecting Percentage to evaluate the curve
            v = XSIMath.MapWorldPositionToObjectSpace(crv.Kinematics.Global.Transform, self.guide.pos[name])
            a = crv.ActivePrimitive.Geometry.GetClosestCurvePosition2(v)
            perc = crv.ActivePrimitive.Geometry.Curves(0).GetPercentageFromU(a[2])
            self.percentages.append(perc)

        # Constrained Curve -------------------------------
        self.cns_crv = []
        self.loc = []
        for i in range(self.crv_count):
            positions = []
            for crv, perc in zip(self.crv, self.percentages):

                if i < self.inter_crv:
                    perc = (i+1.0)/(self.inter_crv+1.0) * perc
                elif i > self.inter_crv:
                    perc = perc + (i-self.inter_crv)/(self.inter_crv+1.0) * perc

                pos = crv.ActivePrimitive.Geometry.Curves(0).EvaluatePositionFromPercentage(perc)[0]
                pos = XSIMath.MapObjectPositionToWorldSpace(crv.Kinematics.Global.Transform, pos)
                positions.append(pos)

            positions.insert(1, vec.linearlyInterpolate(positions[0], positions[1], .1))
            positions.insert(-1, vec.linearlyInterpolate(positions[-2], positions[-1], .9))
            cns_crv = cur.addCurveFromPos(self.root, self.getName("cns%s_crv"%i), positions, False, 3)

            self.cns_crv.append(cns_crv)
            self.addToGroup(cns_crv, "hidden")

            # Shadows
            for j in range(self.shd_count):

                if i < self.inter_crv:
                    name = "%s_low%s"%(j,i)
                elif i == self.inter_crv:
                    name = str(j)
                elif i > self.inter_crv:
                    name = "%s_upp%s"%(j,i-self.inter_crv-1)

                loc = pri.addNullFromPos(cns_crv, self.getName(name+"_loc"), XSIMath.CreateVector3(), self.size*.05)
                self.addShadow(loc, name)

                self.loc.append(loc)
                self.addToGroup(loc, "hidden")
Ejemplo n.º 5
0
    def addObjects(self):

        self.normal = self.getNormalFromPos(self.guide.apos)

        self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
        self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
        self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])

        # FK Controlers ------------------------------------
        t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate)
        self.fk0_ctl = self.addCtl(self.root, "fk0_ctl", t, self.color_fk, "circle", w=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0), ro=XSIMath.CreateRotation(0,0,3.1415*.5))
        xsi.SetNeutralPose(self.fk0_ctl)
        par.setKeyableParameters(self.fk0_ctl)
        par.addLocalParamToCollection(self.inv_params, self.fk0_ctl, ["posx", "posy", "posz"])

        t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate)
        self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "circle", w=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0), ro=XSIMath.CreateRotation(0,0,3.1415*.5))
        xsi.SetNeutralPose(self.fk1_ctl, c.siST)
        par.setKeyableParameters(self.fk1_ctl)
        par.addLocalParamToCollection(self.inv_params, self.fk1_ctl, ["posx", "posy", "posz"])

        t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate)
        self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "circle", w=self.size*.1, ro=XSIMath.CreateRotation(0,0,3.1415*.5))
        xsi.SetNeutralPose(self.fk2_ctl, c.siST)
        par.setKeyableParameters(self.fk2_ctl)
        par.addLocalParamToCollection(self.inv_params, self.fk2_ctl, ["posx", "posy", "posz"])

        # IK Controlers ------------------------------------
        self.ik_cns = pri.addNullFromPos(self.root, self.getName("ik_cns"), self.guide.apos[2], self.size*.02)
        self.addToGroup(self.ik_cns, "hidden")

        self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", self.ik_cns.Kinematics.Global.Transform, self.color_ik, "null", h=self.size*.2)
        par.setKeyableParameters(self.ikcns_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ikcns_ctl, ["posx", "rotx", "rotz"])

        t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.x_axis, "zx", False)
        self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "circle", w=self.size*.2)
        self.addToCtlGroup(self.ik_ctl)
        par.setKeyableParameters(self.ik_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])

        v = XSIMath.CreateVector3()
        v.Sub(self.guide.apos[2], self.guide.apos[0])
        v.Cross(self.normal, v)
        v.NormalizeInPlace()
        v.ScaleInPlace(self.size*.5)
        v.AddInPlace(self.guide.apos[1])
        self.upv_cns = pri.addNullFromPos(self.root, self.getName("upv_cns"), v, self.size*.02)
        self.addToGroup(self.upv_cns, "hidden")

        self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", self.upv_cns.Kinematics.Global.Transform, self.color_ik, "diamond", w=self.size*.05)
        par.setKeyableParameters(self.upv_ctl, self.t_params)
        par.addLocalParamToCollection(self.inv_params, self.upv_ctl, ["posx"])

        self.ik_ref = pri.addNull(self.ik_ctl, self.getName("ik_ref"), self.ik_ctl.Kinematics.Global.Transform, self.size * .1)
        self.addToGroup(self.ik_ref, "hidden")

        # Chain --------------------------------------------
        self.chain = pri.add2DChain(self.root, self.getName(""), self.guide.apos[:-1], self.normal, self.negate, 1, False)
        self.ctrn_loc = pri.addNullFromPos(self.chain.bones[0], self.getName("ctrn_loc"), self.guide.pos["knee"], self.size*.1)
        self.addToGroup(self.chain.all, "hidden")
        self.addToGroup(self.ctrn_loc, "hidden")

        # leash
        self.leash_crv = cur.addCnsCurve(self.root, self.getName("leash_crv"), [self.chain.bones[1], self.upv_ctl], False, 1)
        self.addToGroup(self.leash_crv, "unselectable")

        # shadows
        self.settings["division0"] = 4
        self.settings["division1"] = 4

        self.div0_loc = []
        for i in range(self.settings["division0"]):
            d = min(i/(self.settings["division0"]-1.0), 1-(.5/(self.settings["division0"]-1.0)))

            t = self.chain.bones[0].Kinematics.Global.Transform
            t.SetTranslation(vec.linearlyInterpolate(self.guide.pos["root"], self.guide.pos["knee"], d))
            div_loc = pri.addNull(self.chain.bones[0], self.getName("div%s_loc"%(i)), t, self.size*.05)
            self.addShadow(div_loc, i)
            self.div0_loc.append(div_loc)

        self.addShadow(self.ctrn_loc, self.settings["division0"])

        self.div_loc = []
        for i in range(self.settings["division1"]):
            d = max(i/(self.settings["division1"]-1.0), .5/(self.settings["division1"]-1.0))

            t = self.chain.bones[1].Kinematics.Global.Transform
            t.SetTranslation(vec.linearlyInterpolate(self.guide.pos["knee"], self.guide.pos["ankle"], d))
            div_loc = pri.addNull(self.chain.bones[1], self.getName("div%s_loc"%(i+self.settings["division0"]+1)), t, self.size*.05)
            self.addShadow(div_loc, i+self.settings["division0"]+1)
            self.div_loc.append(div_loc)

        self.addToGroup(self.div0_loc, "hidden")
        self.addToGroup(self.div_loc, "hidden")

        # Hook ----------------------------------------------
        t = self.chain.bones[1].Kinematics.Global.Transform
        t.SetTranslation(self.guide.pos["ankle"])
        self.end_ref = pri.addNull(self.chain.bones[1], self.getName("end_ref"), t, self.size * .1)
        self.addToGroup(self.end_ref, "hidden")

        self.addShadow(self.end_ref, "end")
Ejemplo n.º 6
0
    def addObjects(self):

        self.inter_shd = 1
        self.shd_count = self.inter_shd * 2 + 3
        self.inter_crv = 1
        self.crv_count = self.inter_crv * 2 + 1

        self.npo = []
        self.ctl = []

        self.crv = []
        self.upv = []
        self.ctr = []
        self.off = []
        self.cns_crv = []
        self.loc = []

        self.percentages = []

        for i, name, blade in zip(range(3), ["root", "mid_loc", "end_loc"],
                                  ["blade", "mid_blade", "end_blade"]):

            # Path ----------------------------------------
            crv = self.guide.prim["%s_crv" % i].create(
                self.root, self.getName("%s_crv" % i), None)
            xsi.SetNeutralPose(crv)

            self.crv.append(crv)
            self.addToGroup(crv, "hidden")

            if i == 0:
                y0 = cur.getGlobalPointPosition(0, crv).Y
                y1 = cur.getGlobalPointPosition(
                    crv.ActivePrimitive.Geometry.Points.Count - 1, crv).Y

                self.scale = (y1 - y0) * .5

            # Controlers ----------------------------------
            lookat = XSIMath.CreateVector3()
            lookat.Add(self.guide.pos[name], self.guide.blades[blade].x)
            if blade == "end_blade":
                axisPlane = "zx"
                axisNegate = True
            else:
                axisPlane = "zx"
                axisNegate = False
            t = tra.getTransformLookingAt(self.guide.pos[name], lookat,
                                          self.guide.blades[blade].y,
                                          axisPlane, axisNegate)
            t.SetScaling(
                XSIMath.CreateVector3(self.scale, self.scale, self.scale))

            npo = pri.addNull(self.root, self.getName("%s_npo" % i), t, 1)
            pri.setNullDisplay(npo, 0, 1, 4, 0, 0, 0, .15, 2, 0)
            self.addToGroup(npo, "unselectable")

            ctl = self.addCtl(npo,
                              "%s_ctl" % i,
                              t,
                              self.color_ik,
                              "sphere",
                              w=.2)
            xsi.SetNeutralPose(ctl)
            par.setKeyableParameters(ctl, [
                "posx", "posy", "posz", "rotx", "roty", "rotz", "rotorder",
                "sclx"
            ])
            # par.addLocalParamToCollection(self.inv_params, ctl, ["posx", "roty", "rotz"]) # to be defined
            # par.setRotOrder(ctl, "XZY") # to be defined

            self.ctl.append(ctl)

            # Up Vector, Center, Offset -------------------
            v = XSIMath.CreateVector3(self.guide.blades[blade].x.X,
                                      self.guide.blades[blade].x.Y,
                                      self.guide.blades[blade].x.Z)
            v.ScaleInPlace(-self.size)
            v.AddInPlace(self.guide.pos[name])
            upv = pri.addNullFromPos(crv,
                                     self.getName("%s_upv") % i, v,
                                     self.size * .025)
            ctr = [
                pri.addNullFromPos(crv, self.getName("%s_%s_ctr" % (i, j)),
                                   self.guide.apos[i], self.size * .025)
                for j in range(3)
            ]
            off = pri.addNullFromPos(ctr[1],
                                     self.getName("%s_off") % i,
                                     self.guide.apos[i], self.size * .05)

            self.upv.append(upv)
            self.ctr.append(ctr)
            self.off.append(off)
            self.addToGroup(upv, "hidden")
            self.addToGroup(ctr, "hidden")
            self.addToGroup(off, "hidden")

            # Collecting Percentage to evaluate the curve
            v = XSIMath.MapWorldPositionToObjectSpace(
                crv.Kinematics.Global.Transform, self.guide.pos[name])
            a = crv.ActivePrimitive.Geometry.GetClosestCurvePosition2(v)
            perc = crv.ActivePrimitive.Geometry.Curves(0).GetPercentageFromU(
                a[2])
            self.percentages.append(perc)

        # Constrained Curve -------------------------------
        self.cns_crv = []
        self.loc = []
        for i in range(self.crv_count):
            positions = []
            for crv, perc in zip(self.crv, self.percentages):

                if i < self.inter_crv:
                    perc = (i + 1.0) / (self.inter_crv + 1.0) * perc
                elif i > self.inter_crv:
                    perc = perc + (i - self.inter_crv) / (self.inter_crv +
                                                          1.0) * perc

                pos = crv.ActivePrimitive.Geometry.Curves(
                    0).EvaluatePositionFromPercentage(perc)[0]
                pos = XSIMath.MapObjectPositionToWorldSpace(
                    crv.Kinematics.Global.Transform, pos)
                positions.append(pos)

            positions.insert(
                1, vec.linearlyInterpolate(positions[0], positions[1], .1))
            positions.insert(
                -1, vec.linearlyInterpolate(positions[-2], positions[-1], .9))
            cns_crv = cur.addCurveFromPos(self.root,
                                          self.getName("cns%s_crv" % i),
                                          positions, False, 3)

            self.cns_crv.append(cns_crv)
            self.addToGroup(cns_crv, "hidden")

            # Shadows
            for j in range(self.shd_count):

                if i < self.inter_crv:
                    name = "%s_low%s" % (j, i)
                elif i == self.inter_crv:
                    name = str(j)
                elif i > self.inter_crv:
                    name = "%s_upp%s" % (j, i - self.inter_crv - 1)

                loc = pri.addNullFromPos(cns_crv, self.getName(name + "_loc"),
                                         XSIMath.CreateVector3(),
                                         self.size * .05)
                self.addShadow(loc, name)

                self.loc.append(loc)
                self.addToGroup(loc, "hidden")
Ejemplo n.º 7
0
    def addObjects(self):

        # Ik Controlers ------------------------------------
        t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
                                      self.guide.blades["blade"].z, "yx",
                                      self.negate)
        self.ik0_ctl = self.addCtl(self.root,
                                   "ik0_ctl",
                                   t,
                                   self.color_ik,
                                   "compas",
                                   w=self.size)
        par.setKeyableParameters(self.ik0_ctl)
        xsi.SetNeutralPose(self.ik0_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ik0_ctl,
                                      ["posx", "roty", "rotz"])
        par.setRotOrder(self.ik0_ctl, "XZY")

        t.SetTranslation(self.guide.apos[1])
        self.ik1_ctl = self.addCtl(self.root,
                                   "ik1_ctl",
                                   t,
                                   self.color_ik,
                                   "compas",
                                   w=self.size)
        par.setKeyableParameters(self.ik1_ctl)
        xsi.SetNeutralPose(self.ik1_ctl)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl,
                                      ["posx", "roty", "rotz"])
        par.setRotOrder(self.ik1_ctl, "XZY")

        # Tangent controlers -------------------------------
        t.SetTranslation(
            vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1],
                                    .33))
        self.tan0_ctl = self.addCtl(self.ik0_ctl,
                                    "tan0_ctl",
                                    t,
                                    self.color_ik,
                                    "sphere",
                                    w=self.size * .2)
        par.setKeyableParameters(self.tan0_ctl, self.t_params)
        xsi.SetNeutralPose(self.tan0_ctl, c.siTrn)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl, ["posx"])

        t.SetTranslation(
            vec.linearlyInterpolate(self.guide.apos[0], self.guide.apos[1],
                                    .66))
        self.tan1_ctl = self.addCtl(self.ik1_ctl,
                                    "tan1_ctl",
                                    t,
                                    self.color_ik,
                                    "sphere",
                                    w=self.size * .2)
        par.setKeyableParameters(self.tan1_ctl, self.t_params)
        xsi.SetNeutralPose(self.tan1_ctl, c.siTrn)
        par.addLocalParamToCollection(self.inv_params, self.ik1_ctl, ["posx"])

        # Curves -------------------------------------------
        self.mst_crv = cur.addCnsCurve(
            self.root, self.getName("mst_crv"),
            [self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], False,
            3)
        self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"),
                                    [1] * 10 * 4, False, 3)
        self.addToGroup([self.mst_crv, self.slv_crv], "hidden")

        # Division -----------------------------------------
        # The user only define how many intermediate division he wants.
        # First and last divisions are an obligation.
        parentdiv = self.ik0_ctl
        parentctl = self.ik0_ctl
        self.div_cns = []
        self.fk_ctl = []
        for i in range(self.settings["division"]):

            # References
            div_cns = parentdiv.AddNull(self.getName("%s_cns" % i))
            pri.setNullDisplay(div_cns, 1, self.size * .05, 10, 0, 0, 0, 1, 1,
                               2)
            self.addToGroup(div_cns, "hidden")

            self.div_cns.append(div_cns)
            parentdiv = div_cns

            # Controlers (First and last one are fake)
            if i in [0, self.settings["division"] - 1]:
                fk_ctl = pri.addNull(parentctl, self.getName("%s_loc" % i),
                                     parentctl.Kinematics.Global.Transform,
                                     self.size * .05)
                self.addToGroup(fk_ctl, "hidden")
            else:
                fk_ctl = self.addCtl(parentctl,
                                     "fk%s_ctl" % (i - 1),
                                     parentctl.Kinematics.Global.Transform,
                                     self.color_fk,
                                     "cube",
                                     w=self.size * 1,
                                     h=self.size * .05,
                                     d=self.size * 1)
                self.addToGroup(fk_ctl, "controlers_01")
                par.addLocalParamToCollection(self.inv_params, fk_ctl,
                                              ["posx", "roty", "rotz"])
                par.setRotOrder(fk_ctl, "XZY")

            self.fk_ctl.append(fk_ctl)
            parentctl = fk_ctl

            # Deformers (Shadow)
            self.addShadow(fk_ctl, (i))

        # Connections (Hooks) ------------------------------
        self.cnx0 = pri.addNull(self.root, self.getName("0_cnx"),
                                self.root.Kinematics.Global.Transform,
                                self.size * .2)
        self.cnx1 = pri.addNull(self.root, self.getName("1_cnx"),
                                self.root.Kinematics.Global.Transform,
                                self.size * .2)
        self.addToGroup([self.cnx0, self.cnx1], "hidden")