Esempio n. 1
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)
Esempio n. 2
0
 def __init__(self):
     self.attr = util.BasicAttr()
     
     self.headID = r'941e5133-6d8f-4a2a-853f-f4d3588c3b95'
     self.mesh = rs.coercemesh(self.headID)
     
     self.pn = perlin.SimplexNoise()
     pt = rg.Point3d(10,60,80)
     vec = rg.Vector3d(0,-10, 10)
     plane = rg.Plane(pt, vec)
     xint = rg.Interval(0, 80)
     yint = rg.Interval(0, 80)
     xcount = 10
     ycount = 10
     #self.mesh = rg.Mesh.CreateFromPlane(plane, xint, yint, xcount, ycount)
     #self.meshOrig = self.mesh.Duplicate()
     
     if False:
         for i, v in enumerate(self.mesh.Vertices):
             val = self.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 * 20
             xform = rg.Transform.Translation(vec)
             v.Transform(xform)
             self.mesh.Vertices[i] = v
         
         for i, v in enumerate(self.mesh.Vertices):
             val = self.pn.noise3(util.Remap(v.X, 10, 90, 0, 1), util.Remap(v.Y, 0, 50, 0, 1), 0)
             vec = self.meshOrig.Normals[i]
             vec = rg.Vector3d(vec)
             vec *= val * 30
             xform = rg.Transform.Translation(vec)
             v.Transform(xform)
             self.mesh.Vertices[i] = v
         
         
         
         for i, v in enumerate(self.mesh.Vertices):
             rand = geo.RandomVector3d(4)
             
             self.mesh.Vertices[i] += rg.Vector3f(rand.X, rand.Y, rand.Z)
         
     self.vObjects = []
     for i, v in enumerate(self.mesh.Vertices):
         self.vObjects.append(vObject(self, v, i))
         
     self.meshID = None
Esempio n. 3
0
    def __init__(self):
        self.particles = []
        self.m = rg.Mesh()
        self.mID = None
        self.pn = perlin.SimplexNoise()

        for i in range(30):
            self.particles.append(Particle(self))

        for item in self.particles:
            item.AssignNeighbors()

        #self.m = rg.Mesh()
        #for item in self.particles:
        #    item.CreateMesh()

        self.mID = sc.doc.Objects.AddMesh(self.m)
Esempio n. 4
0
    def __init__(self):
        self.headID = r'941e5133-6d8f-4a2a-853f-f4d3588c3b95'
        self.head = rs.coercemesh(self.headID)
        bb = self.head.GetBoundingBox(rg.Plane.WorldXY)
        yscale = 1 / bb.Max.Y
        zscale = 1 / bb.Max.Z
        xform = rg.Transform.Scale(rg.Plane.WorldXY, 1, yscale, 1)
        self.head.Transform(xform)

        self.pn = perlin.SimplexNoise()
        pt = rg.Point3d(10, 60, 80)
        vec = rg.Vector3d(0, -10, 10)
        plane = rg.Plane(pt, vec)
        xint = rg.Interval(0, 80)
        yint = rg.Interval(0, 80)
        xcount = 10
        ycount = 10
        self.mesh = rg.Mesh.CreateFromPlane(plane, xint, yint, xcount, ycount)
        self.meshOrig = self.mesh.Duplicate()

        for i, v in enumerate(self.mesh.Vertices):
            val = self.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 = self.pn.noise3(util.Remap(v.X, 10, 90, 0, 1),
                                 util.Remap(v.Y, 0, 50, 0, 1), 0)
            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
        self.meshID = None
        self.headsID = None
Esempio n. 5
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
Esempio n. 6
0
 def __init__(self):
     self.particles = []
     self.m = rg.Mesh()
     self.mID = None
     self.pn = perlin.SimplexNoise()
     size = 10
     spacing = 90/(size-1)
     for i in range(size):
         row = []
         for j in range(size):
             row.append(Particle(self, (i*spacing)+5, (j*spacing)+5, j, i))
         self.particles.append(row)
     
     for row in self.particles:
         for item in row:
             item.AssignNeighbors()
     
     self.m = rg.Mesh()
     for row in self.particles:
         for item in row:
             item.CreateMesh()
     
     self.mID = sc.doc.Objects.AddMesh(self.m)
Esempio n. 7
0
    def __init__(self, tile_size=(32, 32)):
        super(InfiniteMap, self).__init__()
        self.NOISE_SIZE = 32
        self.base_tiler = perlin.SimplexNoise()

        # required for pyscroll
        self._old_view = None
        self.tile_size = tile_size
        self.map_size = 1024, 1024
        self.visible_tile_layers = [0]

        self.last_value = 0
        self.last_x = None
        self.last_y = None
        self.scan_x = 0
        self.total_checks = 0
        self.cached_checks = 0

        self.seen_tiles = set()
        self.biome_map = [array('B', [0] * 1024) for i in range(1024)]
        self.tile_map = [array('H', [0] * 1024) for i in range(1024)]

        self.font = None

        self.tilesets = {
            'ldirt-empty': (112, 49, 48, 80, 17, 111, None, 79, 16, None, 113,
                            81, 144, 143, 145, 47),
            'sand-empty': (385, 322, 321, 353, 290, 384, None, 352, 289, None,
                           386, 354, 417, 416, 418, 320),
            'water-grass': (391, 328, 327, 359, 296, 390, None, 358, 295, None,
                            392, 360, 423, 422, 424, 326),
            'grass': (118, 183, 182, 181, 374),
            'wall': (38, None, None, 6, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 0),
        }
        self.all_tiles = list()

        self.load_texture()