Example #1
0
    def __init__(self):
        self.p = Target(rg.Point3d(50, 50, 50), rg.Vector3d(.05, 0.05, 0.05))
        self.dots = []
        self.time = 0
        self.links = []
        self.id = None
        self.grad = color.GetGradient(10)
        self.mesh = rg.Mesh()
        self.pn = perlin.SimplexNoise()
        for i in range(1000):
            self.dots.append(Dot(self))

        #Attr
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(10)
        self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index
Example #2
0
    def __init__(self, mesh):
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(4)
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        self.mesh = mesh.Duplicate()
        self.meshOrig = mesh.Duplicate()
        self.ids = []
        self.vObjects = []
        self.targets = []
        for i in range(len(self.mesh.Vertices)):
            self.targets.append(i)

        for i, v in enumerate(self.mesh.Vertices):
            self.vObjects.append(vObject(self, v, i))

        self.sourceIndex = random.randint(0, len(self.mesh.Vertices))
        self.vObjects[self.sourceIndex].UpdateDisplay()

        while True:
            self.targetIndex = random.randint(0, len(self.mesh.Vertices))
            if self.targetIndex != self.sourceIndex: break
        self.path = None
        self.targets.Remove(self.sourceIndex)

        pn = perlin.SimplexNoise()
        for i, v in enumerate(self.mesh.Vertices):
            val = pn.noise2(util.Remap(v.X, 10, 90, 0, 3),
                            util.Remap(v.Y, 0, 50, 0, 3))
            vec = self.meshOrig.Normals[i]
            vec = rg.Vector3d(vec)
            vec *= val * 8
            xform = rg.Transform.Translation(vec)
            v.Transform(xform)
            self.mesh.Vertices[i] = v

        for i, v in enumerate(self.mesh.Vertices):
            val = pn.noise2(util.Remap(v.X, 10, 90, 0, 1),
                            util.Remap(v.Y, 0, 50, 0, 1))
            vec = self.meshOrig.Normals[i]
            vec = rg.Vector3d(vec)
            vec *= val * 20
            xform = rg.Transform.Translation(vec)
            v.Transform(xform)
            self.mesh.Vertices[i] = v
        sc.doc.Objects.AddMesh(self.mesh)

        sphere = rg.Sphere(self.vObjects[self.sourceIndex].vertex, 4)
        sc.doc.Objects.AddSphere(sphere)
Example #3
0
    def __init__(self):
        #self.system = system
        #self.pos = rg.Point3d(random.uniform(10,90), random.uniform(10,90), 90)
        self.width = 9
        self.depth = 9
        self.height = 9
        self.pos = rg.Point3d(50, 50, 50)

        self.vel = rg.Vector3d(random.uniform(-2, 2), random.uniform(-2, 2),
                               random.uniform(-2, 2))
        self.vel.Unitize()
        self.vel *= 5
        self.acc = rg.Point3d(50, 50, 50) - self.pos
        self.acc.Unitize()
        self.acc *= .1

        self.prevPos = self.pos
        xSize = rg.Interval(-self.width / 2, self.width / 2)
        ySize = rg.Interval(-self.depth / 2, self.depth / 2)
        zSize = rg.Interval(-self.height / 2, self.height / 2)

        self.prevPos = self.pos
        self.futureVel = None
        self.vel += self.acc
        self.futurePos = rg.Point3d.Add(self.pos, self.vel)

        self.ids = []
        self.age = 0

        self.plane = rg.Plane.WorldXY
        self.plane.Origin = self.pos
        self.box = rg.Box(self.plane, xSize, ySize, zSize)
        self.boxBrep = self.box.ToBrep()
        self.id = sc.doc.Objects.AddBrep(self.boxBrep)

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(1)
        self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.prevBrep = None
        self.edgesPrev = []
Example #4
0
    def __init__(self, mesh):
        self.mesh = mesh
        self.ids = []
        self.vObjects = []
        for i, v in enumerate(self.mesh.Vertices):
            self.vObjects.append(vObject(self, v, i))

        self.sourceIndex = random.randint(0, len(self.mesh.Vertices))
        while True:
            self.targetIndex = random.randint(0, len(self.mesh.Vertices))
            if self.targetIndex != self.sourceIndex: break
        self.path = None

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(5)
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
Example #5
0
    def __init__(self, system):
        self.system = system
        self.val = None
        self.history = []
        self.historyPos = []
        self.pipeIDs = []
        self.pipe = None

        #Movement
        self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
                               random.uniform(-1, 1))
        self.vel.Unitize()
        self.speed = 4
        self.vel *= self.speed
        self.acc = rg.Vector3d(0, 0, 0)
        self.size = 5
        self.cone = None
        self.coneID = None
        self.rotAngle = 0

        #Color and Material
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        grad = color.GetGradient(1)
        self.attr.ObjectColor = color.GradientOfColors(grad,
                                                       random.uniform(0, 1))
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        #Position
        self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
                              random.uniform(5, 95))
        self.plane = rg.Plane(self.pos, self.vel)
        #self.sphere = rg.Sphere(self.pos, self.size )

        #Bake
        self.tempIDs = []
        self.ids = []
        #self.ids.append(sc.doc.Objects.AddSphere(self.sphere, self.attr))
        self.coneIDs = []
Example #6
0
    def __init__(self, system, vec=None):
        self.system = system
        self.majorBrep = rg.Brep()
        self.alive = True
        self.age = 0

        #Movement
        self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
                               random.uniform(-.2, .2))
        self.vel.Unitize()
        #self.size = random.uniform(1, 3)
        self.size = 1
        self.length = self.size * 2

        #Color and Material
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        #self.grad = color.GetGradient(random.randint(0,9))
        self.grad = color.GetGradient(4)
        col = drawing.Color.AliceBlue
        #col = color.GradientOfColors(self.grad, random.uniform(0,1))
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        self.attr.ObjectColor = col
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        #Position
        self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95), .1)
        #self.pos =  rg.Point3d(50, 50, 50)
        initPlane = rg.Plane.WorldXY
        initPlane.Origin = self.pos
        self.openPlanes = []
        self.planesToRemove = []
        self.nextRoundPlanes = [initPlane]

        self.crv = None
        self.crvs = rc.Collections.CurveList()
        self.pts = []

        sc.doc.Objects.AddSphere(rg.Sphere(self.pos, self.size), self.attr)
Example #7
0
    def Update(self, time):
        grad = color.GetGradient(1)
        self.attr.ObjectColor = color.GradientOfColors(
            grad, util.Remap(time, 0, 150, 0, 1))
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.openPlanes = self.nextRoundPlanes
        self.openPlanes = self.openPlanes[:8]
        self.nextRoundPlanes = []

        planesToRemove = []
        for plane in self.openPlanes:
            planesToRemove.append(plane)
            self.AddModule(plane)

        for plane in planesToRemove:
            self.openPlanes.remove(plane)
Example #8
0
    def __init__(self):
        self.particles = []
        self.targetID = r'8d8dd842-3d3f-4f65-b7d4-e4089e4f9cbb'
        self.target = rs.coercemesh(self.targetID)
        self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
                               rg.Interval(0, 100), rg.Interval(0, 100))
        self.boundary = self.boundary.ToBrep()

        self.time = 0

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject

        grad = color.GetGradient(1)
        self.attr.ObjectColor = color.GradientOfColors(grad, 0)
        self.attr.ObjectColor = drawing.Color.White
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject

        self.clays = []
        #numClays = 1
        #for i in range(numClays):
        #    self.clays.append(Clay(self, color.GradientOfColors(grad, i/numClays), rg.Interval(25+(i*10), 35+(i*10))))
        numClays = 1
        self.clays.append(
            Clay(self, color.GradientOfColors(grad, 0), rg.Interval(25, 75)))

        self.particles = []
        for i in range(12):
            self.particles.append(Particle(self))
Example #9
0
    def __init__(self, system):
        self.system = system
        self.pos = rg.Point3d(random.uniform(10, 90), random.uniform(10, 90),
                              random.uniform(10, 90))
        self.vel = rg.Vector3d(random.uniform(-2, 2), random.uniform(-2, 2),
                               random.uniform(-2, 2))
        self.vel.Unitize()
        self.vel *= 5
        self.acc = rg.Point3d(50, 50, 50) - self.pos
        self.acc.Unitize()
        self.acc *= .1

        self.vel += self.acc
        self.id = None
        self.ids = []
        self.age = 0

        self.prevPlane = rg.Plane.WorldXY
        self.xform = None

        #Attr
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(2)
        self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        size = .5
        self.pt0 = rg.Point3f(0, size, 0)
        self.pt1 = rg.Point3f(-size / 2, 0, 0)
        self.pt2 = rg.Point3f(size / 2, 0, 0)
        self.mesh = self.InitTriangle()
Example #10
0
    def __init__(self):
        self.particles = []

        self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
                               rg.Interval(0, 100), rg.Interval(0, 100))
        self.boundary = self.boundary.ToBrep()

        initPlane = rg.Plane.WorldXY
        initPlane.Origin = rg.Point3d(50, 50, 50)

        self.majorBrep = rg.Brep()
        self.breps = []

        self.openPlanes = []
        self.deadPlanes = []
        self.nextRoundPlanes = [initPlane]
        self.modules = []

        self.size = 6
        self.time = 0

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject

        grad = color.GetGradient(5)
        self.attr.ObjectColor = color.GradientOfColors(grad, 0)
        self.attr.ObjectColor = drawing.Color.White
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.voxels = []
        for i in range(1):
            self.voxels.append(Module(self, self.size, rg.Point3d(50, 50, 50)))
Example #11
0
    def __init__(self):
        self.particles = []

        self.boundary = rg.Box(rg.Plane.WorldXY, rg.Interval(0, 100),
                               rg.Interval(0, 100), rg.Interval(0, 100))
        self.boundary = self.boundary.ToBrep()

        self.time = 0

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject

        grad = color.GetGradient(1)
        self.attr.ObjectColor = color.GradientOfColors(grad, 0)
        self.attr.ObjectColor = drawing.Color.White
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject

        self.clays = []
        #numClays = 1
        #for i in range(numClays):
        #    self.clays.append(Clay(self, color.GradientOfColors(grad, i/numClays), rg.Interval(25+(i*10), 35+(i*10))))
        numClays = 1
        self.clays.append(
            Clay(self, color.GradientOfColors(grad, 0), rg.Interval(0, 30)))

        self.balls = []
        for i in range(4):
            self.balls.append(Ball(self))
Example #12
0
    def __init__(self, system, vec=None):
        self.system = system
        self.val = None
        self.history = []
        self.historyPos = []
        self.pipeIDs = []
        self.pipe = None
        self.pipes = []
        self.alive = True
        self.size = random.uniform(1, 6)
        self.length = self.size * 2
        self.turned = False
        self.prevVel = None
        self.majorBrep = rg.Brep()
        self.prevBrep = None
        self.planes = []
        self.ids = []
        self.breps = []

        self.straightSec = Module(self.size)
        self.straightSec.CreateStraight()
        self.angleSec = Module(self.size)
        self.angleSec.CreateAngle()
        self.uTurnSec = Module(self.size)
        self.uTurnSec.CreateUturn()
        self.TSec = Module(self.size)
        self.TSec.CreateT()

        self.cases = {
            0: rg.Vector3d(1, 0, 0),
            1: rg.Vector3d(-1, 0, 0),
            2: rg.Vector3d(0, 1, 0),
            3: rg.Vector3d(0, -1, 0),
            4: rg.Vector3d(0, 0, 1),
            5: rg.Vector3d(0, 0, -1)
        }

        self.case = random.randint(0, len(self.cases) - 1)

        #Movement
        #self.vel = rg.Vector3d(random.uniform(-1,1),random.uniform(-1,1), random.uniform(-.2,.2))
        if vec is None:
            self.vel = random.choice(self.cases)
        else:
            self.vel = vec
        self.vel.Unitize()
        self.tempVel = self.vel.Clone()
        self.speed = self.length
        self.vel *= self.speed
        self.acc = rg.Vector3d(0, 0, 0)
        self.size = 2
        self.cone = None
        self.coneID = None
        self.rotAngle = 0

        #Color and Material
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        #self.grad = color.GetGradient(random.randint(0,9))
        self.grad = color.GetGradient(4)
        #col = drawing.Color.AliceBlue
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        self.attr.ObjectColor = color.GradientOfColors(self.grad,
                                                       random.uniform(0, 1))
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        self.attrCol1 = rc.DocObjects.ObjectAttributes()
        self.attrCol1.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attrCol1.ObjectColor = drawing.Color.Red
        self.attrCol2 = rc.DocObjects.ObjectAttributes()
        self.attrCol2.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attrCol2.ObjectColor = drawing.Color.Green
        self.attrCol3 = rc.DocObjects.ObjectAttributes()
        self.attrCol3.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.attrCol3.ObjectColor = drawing.Color.Blue

        #Position
        self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
                              random.uniform(5, 95))
        #self.pos =  rg.Point3d(50, 50, 50)
        self.plane = rg.Plane(self.pos, self.vel)
        self.planes.append(self.plane)
        self.origin = rg.Point3d(self.pos)

        #Bake
        self.tempIDs = []
        self.ids = []
        self.coneIDs = []
        self.id = None
Example #13
0
    def __init__(self, system):
        self.system = system
        self.val = None
        self.history = []
        self.historyPos = []
        self.pipeIDs = []
        self.pipe = None
        self.pipes = []
        self.alive = True
        self.length = 4
        self.turned = False
        self.prevVel = None
        self.prevPlane = None

        self.cases = {
            0: rg.Vector3d(1, 0, 0),
            1: rg.Vector3d(-1, 0, 0),
            2: rg.Vector3d(0, 1, 0),
            3: rg.Vector3d(0, -1, 0),
            4: rg.Vector3d(0, 0, 1),
            5: rg.Vector3d(0, 0, -1)
        }

        self.case = random.randint(0, len(self.cases) - 1)

        #Movement
        self.vel = rg.Vector3d(random.uniform(-1, 1), random.uniform(-1, 1),
                               random.uniform(-.2, .2))
        self.vel.Unitize()
        self.tempVel = self.vel.Clone()
        self.speed = self.length
        self.vel *= self.speed
        self.acc = rg.Vector3d(0, 0, 0)
        self.size = 1
        self.cone = None
        self.coneID = None
        self.rotAngle = 0

        #Color and Material
        self.attr = rc.DocObjects.ObjectAttributes()
        self.attr.ColorSource = rc.DocObjects.ObjectColorSource.ColorFromObject
        self.grad = color.GetGradient(random.randint(0, 9))
        #col = drawing.Color.AliceBlue
        self.attr.MaterialSource = rc.DocObjects.ObjectMaterialSource.MaterialFromObject
        self.attr.ObjectColor = color.GradientOfColors(self.grad, 0)
        index = sc.doc.Materials.Add()
        self.mat = sc.doc.Materials[index]
        self.mat.DiffuseColor = self.attr.ObjectColor
        self.mat.CommitChanges()
        self.attr.MaterialIndex = index

        #Position
        self.pos = rg.Point3d(random.uniform(5, 95), random.uniform(5, 95),
                              random.uniform(5, 95))
        #self.pos =  rg.Point3d(50,50,50)
        self.plane = rg.Plane(self.pos, self.vel)
        #self.sphere = rg.Sphere(self.pos, self.size )

        #Bake
        self.tempIDs = []
        self.ids = []
        #self.ids.append(sc.doc.Objects.AddSphere(self.sphere, self.attr))
        self.coneIDs = []