Esempio n. 1
0
def getBoundingBox(scene):
  minimum = Vector() 
  maximum = Vector()

  for obj in scene.objects:
    if obj.type == 'MESH':
      bbox_corners = [obj.matrix_world * Vector(corner) for corner in obj.bound_box]

      for v in bbox_corners:
        if v.x < minimum.x:
          minimum.x = v.x
        if v.y < minimum.y:
          minimum.y = v.y
        if v.z < minimum.z:
          minimum.z = v.z
        if v.x > maximum.x:
          maximum.x = v.x
        if v.y > maximum.y:
          maximum.y = v.y
        if v.z > maximum.z:
          maximum.z = v.z

  return  {
    "minimum" : { "x" : minimum.x, "y" : minimum.y, "z" : minimum.z },
    "maximum" : { "x" : maximum.x, "y" : maximum.y, "z" : maximum.z }
  }
Esempio n. 2
0
def getBoundsBF(obj):
    """ brute force method for obtaining object bounding box """
    # initialize min and max
    min = Vector((math.inf, math.inf, math.inf))
    max = Vector((-math.inf, -math.inf, -math.inf))
    # calculate min and max verts
    for v in obj.data.vertices:
        if v.co.x > max.x:
            max.x = v.co.x
        elif v.co.x < min.x:
            min.x = v.co.x
        if v.co.y > max.y:
            max.y = v.co.y
        elif v.co.y < min.y:
            min.y = v.co.y
        if v.co.z > max.z:
            max.z = v.co.z
        elif v.co.z < min.z:
            min.z = v.co.z
    # set up bounding box list of coord lists
    bound_box = [list(min),
                 [min.x, min.y, min.z],
                 [min.x, min.y, max.z],
                 [min.x, max.y, max.z],
                 [min.x, max.y, min.z],
                 [max.x, min.y, min.z],
                 [max.y, min.y, max.z],
                 list(max),
                 [max.x, max.y, min.z]]
    return bound_box
Esempio n. 3
0
    def relocate(self, itM, o, dx, dy, alt):
        """
          apply delta to child location
        """
        d = archipack_custom_part.datablock(o)
        
        # child location relative to parent
        loc = d.pivot_location.copy()

        # delta location of pivot
        pivot = Vector()

        if loc.x > 0:
            pivot.x = dx
        else:
            pivot.x = -dx
        if loc.y > 0:
            pivot.y = dy
        else:
            pivot.y = -dy
        
        # delta for parent part
        loc += pivot

        # delta for child part
        # move verts so pivot remains constant in child
        cM = Matrix.Translation(-pivot)
        for v in o.data.vertices:
            v.co = cM * v.co
        # Move child so the pivot stay in same location relative to parent
        o.location = loc + Vector((0, 0, alt))
        # store location to child data
        d.pivot_location = loc.copy()
    def calcAlign(self, localArea):
        alnVec = Vector([0, 0, 0])
        if len(localArea) == 0:
            return alnVec
        agents = self.sim.agents
        for neighbour in localArea:
            alnVec.x += agents[neighbour].arx
            alnVec.y += agents[neighbour].ary
            alnVec.z += agents[neighbour].arz
        alnVec /= len(localArea)

        alnVec.x -= agents[self.userid].arx
        alnVec.y -= agents[self.userid].ary
        alnVec.z -= agents[self.userid].arz

        alnVec.x %= 2 * math.pi
        alnVec.y %= 2 * math.pi
        alnVec.z %= 2 * math.pi

        if alnVec.x < math.pi:
            alnVec.x = alnVec.x / math.pi
        else:
            alnVec.x = -2 + alnVec.x / math.pi
        if alnVec.y < math.pi:
            alnVec.y = alnVec.y / math.pi
        else:
            alnVec.y = -2 + alnVec.y / math.pi
        if alnVec.z < math.pi:
            alnVec.z = alnVec.z / math.pi
        else:
            alnVec.z = -2 + alnVec.z / math.pi
        return alnVec
Esempio n. 5
0
def combine_bounds(bounds: Iterable[BoundsDataStruct_YK1]) -> BoundsDataStruct_YK1:
    # min_pos = None
    # max_pos = None
    min_pos = Vector((-1000, -1000, -1000))
    max_pos = Vector((+1000, +1000, +1000))

    for bound in bounds:
        min_for_bound = bound.center - bound.box_extents
        max_for_bound = bound.center - bound.box_extents

        if min_pos is None:
            min_pos = min_for_bound
            max_pos = max_for_bound
        else:
            min_pos.x = min(min_for_bound.x, min_pos.x)
            min_pos.y = min(min_for_bound.y, min_pos.y)
            min_pos.z = min(min_for_bound.z, min_pos.z)

            max_pos.x = max(max_for_bound.x, max_pos.x)
            max_pos.y = max(max_for_bound.y, max_pos.y)
            max_pos.z = max(max_for_bound.z, max_pos.z)

    # TODO - This is for the sake of hierarchy objects which have no meshes themselves, but presumably have children with meshes.
    # Will these BBOXes need to be calculated with those other ones in mind?
    # Will these BBOXes need to be calculated with object position in mind?
    # if min_pos is None:
    #     min_pos = Vector((0, 0, 0, 0))
    #     max_pos = Vector((0, 0, 0, 0))

    return bounds_from_minmax(min_pos, max_pos)
Esempio n. 6
0
    def calcAlign(self, localArea):
        alnVec = Vector([0, 0, 0])
        if len(localArea) == 0:
            return alnVec
        agents = self.sim.agents
        for neighbour in localArea:
            alnVec.x += agents[neighbour].arx
            alnVec.y += agents[neighbour].ary
            alnVec.z += agents[neighbour].arz
        alnVec /= len(localArea)

        alnVec.x -= agents[self.userid].arx
        alnVec.y -= agents[self.userid].ary
        alnVec.z -= agents[self.userid].arz

        alnVec.x %= 2*math.pi
        alnVec.y %= 2*math.pi
        alnVec.z %= 2*math.pi

        if alnVec.x < math.pi:
            alnVec.x = alnVec.x/math.pi
        else:
            alnVec.x = -2 + alnVec.x/math.pi
        if alnVec.y < math.pi:
            alnVec.y = alnVec.y/math.pi
        else:
            alnVec.y = -2 + alnVec.y/math.pi
        if alnVec.z < math.pi:
            alnVec.z = alnVec.z/math.pi
        else:
            alnVec.z = -2 + alnVec.z/math.pi
        return alnVec
Esempio n. 7
0
def get_island_BBOX(island):
    bbox = {}
    bm = bmesh.from_edit_mesh(bpy.context.active_object.data)
    uv_layers = bm.loops.layers.uv.verify()

    boundsMin = Vector((99999999.0, 99999999.0))
    boundsMax = Vector((-99999999.0, -99999999.0))
    boundsCenter = Vector((0.0, 0.0))

    for face in island:
        for loop in face.loops:
            uv = loop[uv_layers].uv
            boundsMin.x = min(boundsMin.x, uv.x)
            boundsMin.y = min(boundsMin.y, uv.y)
            boundsMax.x = max(boundsMax.x, uv.x)
            boundsMax.y = max(boundsMax.y, uv.y)

    bbox['min'] = Vector((boundsMin))
    bbox['max'] = Vector((boundsMax))

    boundsCenter.x = (boundsMax.x + boundsMin.x) / 2
    boundsCenter.y = (boundsMax.y + boundsMin.y) / 2

    bbox['center'] = boundsCenter

    return bbox
Esempio n. 8
0
def readPackedVector(f, format):
    packed = f

    output = Vector()
    if format == 'XZY':
        output.x = packed
        output.y = packed / 65536.0
        output.z = packed / 256.0
    elif format == 'ZXY':
        output.x = packed / 256.0
        output.y = packed / 65536.0
        output.z = packed
    elif format == 'XYZ':
        output.x = packed
        output.y = packed / 256.0
        output.z = packed / 65536.0

    output.x -= math.floor(output.x)
    output.y -= math.floor(output.y)
    output.z -= math.floor(output.z)

    output.x = output.x*2 - 1
    output.y = output.y*2 - 1
    output.z = output.z*2 - 1

    return output
Esempio n. 9
0
def getMultiObjectSelectionBBox(all_ob_bounds):
    multibbox = {}
    boundsMin = Vector((99999999.0, 99999999.0))
    boundsMax = Vector((-99999999.0, -99999999.0))
    boundsCenter = Vector((0.0, 0.0))

    for ob_bounds in all_ob_bounds:
        if len(ob_bounds) > 1:
            boundsMin.x = min(boundsMin.x, ob_bounds['min'].x)
            boundsMin.y = min(boundsMin.y, ob_bounds['min'].y)
            boundsMax.x = max(boundsMax.x, ob_bounds['max'].x)
            boundsMax.y = max(boundsMax.y, ob_bounds['max'].y)

    multibbox['min'] = boundsMin
    multibbox['max'] = boundsMax
    multibbox['width'] = (boundsMax - boundsMin).x
    multibbox['height'] = (boundsMax - boundsMin).y

    boundsCenter.x = (boundsMax.x + boundsMin.x) / 2
    boundsCenter.y = (boundsMax.y + boundsMin.y) / 2

    multibbox['center'] = boundsCenter
    multibbox['area'] = multibbox['width'] * multibbox['height']
    multibbox['minLength'] = min(multibbox['width'], multibbox['height'])

    return multibbox
Esempio n. 10
0
def getBoundsBF(obj:Object):
    """ brute force method for obtaining object bounding box """
    # initialize min and max
    min = Vector((math.inf, math.inf, math.inf))
    max = Vector((-math.inf, -math.inf, -math.inf))
    # calculate min and max verts
    for v in obj.data.vertices:
        if v.co.x > max.x:
            max.x = v.co.x
        elif v.co.x < min.x:
            min.x = v.co.x
        if v.co.y > max.y:
            max.y = v.co.y
        elif v.co.y < min.y:
            min.y = v.co.y
        if v.co.z > max.z:
            max.z = v.co.z
        elif v.co.z < min.z:
            min.z = v.co.z
    # set up bounding box list of coord lists
    bound_box = [list(min),
                 [min.x, min.y, min.z],
                 [min.x, min.y, max.z],
                 [min.x, max.y, max.z],
                 [min.x, max.y, min.z],
                 [max.x, min.y, min.z],
                 [max.y, min.y, max.z],
                 list(max),
                 [max.x, max.y, min.z]]
    return bound_box
Esempio n. 11
0
def analyzeMeshObject(obj, meshFaces):
    global DEFAULT_PART_NAME

    mesh = obj.data
    parts = []
    halfSize = obj.dimensions * 0.5
    candidParts = []
    centerOfMass = Vector((0.0, 0.0, 0.0))
    trianglesCount = 0
    meshVerticesCount = len(mesh.vertices)
    meshMaterialCount = len(mesh.materials)

    if meshMaterialCount > 0:
        # Create parts. It is important to iterate it manually 
        # so material names order is preserved.
        for i in range(meshMaterialCount):
            candidParts.append({'name': mesh.materials[i].name, 'start': 0, 'count': 0})
    else:
        # If there are no materials defined, create default part placeholder.
        candidParts.append({'name': DEFAULT_PART_NAME, 'start': 0, 'count': 0})

    for f in meshFaces:
        # Some faces can be quads - values have to doubled then.
        modifier = 2 if len(f.vertices) == 4 else 1
        candidParts[f.material_index]['count'] += 3 * modifier
        trianglesCount += 1 * modifier

    # Update part`s start attribute so they take other parts into account.
    for i in range(0, len(candidParts)):
        if i > 0:
            candidParts[i]['start'] = candidParts[i - 1]['start'] + candidParts[i - 1]['count']

    # Only export parts that have any triangles assigned.
    for p in candidParts:
        if p['count'] > 0:
            parts.append(p)

    centerMax = Vector((-9999.999, -9999.999, -9999.999))
    centerMin = Vector(( 9999.999,  9999.999,  9999.999))

    for v in mesh.vertices:
        centerMax.x = max(centerMax.x, v.co.x)
        centerMin.x = min(centerMin.x, v.co.x)
        centerMax.y = max(centerMax.y, v.co.y)
        centerMin.y = min(centerMin.y, v.co.y)
        centerMax.z = max(centerMax.z, v.co.z)
        centerMin.z = min(centerMin.z, v.co.z)

    centerOfMass.x = abs(centerMax.x) - abs(centerMin.x)
    centerOfMass.y = abs(centerMax.y) - abs(centerMin.y)
    centerOfMass.z = abs(centerMax.z) - abs(centerMin.z)

    centerOfMass *= 0.5

    return centerOfMass, halfSize, trianglesCount, parts
Esempio n. 12
0
def calcBBPos(x, y, z, a1, a2, a3, type='DNA'):
    bb = Vector()
    if type is 'DNA':
        bb.x = x - (0.34 * a1.x + 0.3408 * a2.x)
        bb.y = y - (0.34 * a1.y + 0.3408 * a2.y)
        bb.z = z - (0.34 * a1.z + 0.3408 * a2.z)
    elif type is 'RNA':
        bb.x = x - (0.4 * a1.x + 0.2 * a3.x)
        bb.y = y - (0.4 * a1.y + 0.2 * a3.y)
        bb.z = z - (0.4 * a1.z + 0.2 * a3.z)
    return bb
Esempio n. 13
0
    def __get_uv_max_min(self, loop_seqs, uv_layer):
        uv_max = Vector((-1000000.0, -1000000.0))
        uv_min = Vector((1000000.0, 1000000.0))
        for hseq in loop_seqs:
            for l in hseq[0]:
                uv = l[uv_layer].uv
                uv_max.x = max(uv.x, uv_max.x)
                uv_max.y = max(uv.y, uv_max.y)
                uv_min.x = min(uv.x, uv_min.x)
                uv_min.y = min(uv.y, uv_min.y)

        return uv_max, uv_min
Esempio n. 14
0
    def __get_uv_max_min(self, loop_seqs, uv_layer):
        uv_max = Vector((-1000000.0, -1000000.0))
        uv_min = Vector((1000000.0, 1000000.0))
        for hseq in loop_seqs:
            for l in hseq[0]:
                uv = l[uv_layer].uv
                uv_max.x = max(uv.x, uv_max.x)
                uv_max.y = max(uv.y, uv_max.y)
                uv_min.x = min(uv.x, uv_min.x)
                uv_min.y = min(uv.y, uv_min.y)

        return uv_max, uv_min
Esempio n. 15
0
def bounding_box(mesh):
    v0 = mesh.vertices[0].co
    vmin = Vector((v0.x, v0.y, v0.z))
    vmax = Vector((v0.x, v0.y, v0.z))
    for i in range(1, len(mesh.vertices)):
        v = mesh.vertices[i].co
        vmin.x = min(vmin.x, v.x)
        vmin.y = min(vmin.y, v.y)
        vmin.z = min(vmin.z, v.z)
        vmax.x = max(vmax.x, v.x)
        vmax.y = max(vmax.y, v.y)
        vmax.z = max(vmax.z, v.z)
    return vmin, vmax
Esempio n. 16
0
def bounding_box(mesh):
    v0 = mesh.vertices[0].co
    vmin = Vector((v0.x, v0.y, v0.z))
    vmax = Vector((v0.x, v0.y, v0.z))
    for i in range(1, len(mesh.vertices)):
        v = mesh.vertices[i].co
        vmin.x = min(vmin.x, v.x)
        vmin.y = min(vmin.y, v.y)
        vmin.z = min(vmin.z, v.z)
        vmax.x = max(vmax.x, v.x)
        vmax.y = max(vmax.y, v.y)
        vmax.z = max(vmax.z, v.z)
    return vmin, vmax
Esempio n. 17
0
    def execute(self, context):
        switchMode = False
        if context.mode != 'OBJECT':
            switchMode = True
            bpy.ops.object.mode_set(mode='OBJECT', toggle=True)

        for o in context.selected_objects:
            if o.type == "MESH":
                d = o.data
                m = o.matrix_world
                if self.center:
                    bounds_center = (sum(
                        (m @ Vector(b) for b in o.bound_box), Vector())) / 8
                    difference = m.translation - bounds_center
                    local_difference = difference @ m
                    for v in d.vertices:
                        v.co += local_difference
                    m.translation -= difference

                difference = Vector((0, 0, 0))
                if self.side == 'X':
                    bound = max((m @ v.co).x for v in d.vertices)
                    difference.x = m.translation.x - bound
                elif self.side == '-X':
                    bound = min((m @ v.co).x for v in d.vertices)
                    difference.x = m.translation.x - bound
                elif self.side == 'Y':
                    bound = max((m @ v.co).y for v in d.vertices)
                    difference.y = m.translation.y - bound
                elif self.side == '-Y':
                    bound = min((m @ v.co).y for v in d.vertices)
                    difference.y = m.translation.y - bound
                elif self.side == 'Z':
                    bound = max((m @ v.co).z for v in d.vertices)
                    difference.z = m.translation.z - bound
                elif self.side == '-Z':
                    bound = min((m @ v.co).z for v in d.vertices)
                    difference.z = m.translation.z - bound

                local_difference = difference @ m
                for v in d.vertices:
                    v.co += local_difference
                m.translation -= difference

                if self.move:
                    o.location = context.scene.cursor.location
        if switchMode:
            bpy.ops.object.mode_set(mode='OBJECT', toggle=True)

        return {'FINISHED'}
Esempio n. 18
0
def XYZ2xyY(xyz):
    """Converts XYZ to xyY"""
    xyY = Vector()
    
    # http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_xyY.html
    div = xyz.x + xyz.y + xyz.z
    if div != 0:
        xyY.x = xyz.x / div
        xyY.y = xyz.y / div
    else:
        xyY.x = D65.x / (D65.x + D65.y + D65.z)
        xyY.y = D65.y / (D65.x + D65.y + D65.z)
    xyY.z = 1.0
    return xyY
Esempio n. 19
0
 def calc_box(self):
     if not self.verts:
         return Vector((0, 0, 0)), Vector((0, 0, 0))
     mins = Vector(self.verts[0])
     maxs = Vector(self.verts[0])
     for v in self.verts:
         mins.x = min(mins.x, v.x)
         mins.y = min(mins.y, v.y)
         mins.z = min(mins.z, v.z)
         maxs.x = max(maxs.x, v.x)
         maxs.y = max(maxs.y, v.y)
         maxs.z = max(maxs.z, v.z)
     size = (maxs - mins)
     center = (maxs + mins) / 2
     return size, center
Esempio n. 20
0
def __get_island_info(uv_layer, islands):
    """
    get information about each island
    """

    island_info = []
    for isl in islands:
        info = {}
        max_uv = Vector((-10000000.0, -10000000.0))
        min_uv = Vector((10000000.0, 10000000.0))
        ave_uv = Vector((0.0, 0.0))
        num_uv = 0
        for face in isl:
            n = 0
            a = Vector((0.0, 0.0))
            ma = Vector((-10000000.0, -10000000.0))
            mi = Vector((10000000.0, 10000000.0))
            for l in face['face'].loops:
                uv = l[uv_layer].uv
                ma.x = max(uv.x, ma.x)
                ma.y = max(uv.y, ma.y)
                mi.x = min(uv.x, mi.x)
                mi.y = min(uv.y, mi.y)
                a = a + uv
                n = n + 1
            ave_uv = ave_uv + a
            num_uv = num_uv + n
            a = a / n
            max_uv.x = max(ma.x, max_uv.x)
            max_uv.y = max(ma.y, max_uv.y)
            min_uv.x = min(mi.x, min_uv.x)
            min_uv.y = min(mi.y, min_uv.y)
            face['max_uv'] = ma
            face['min_uv'] = mi
            face['ave_uv'] = a
        ave_uv = ave_uv / num_uv

        info['center'] = ave_uv
        info['size'] = max_uv - min_uv
        info['num_uv'] = num_uv
        info['group'] = -1
        info['faces'] = isl
        info['max'] = max_uv
        info['min'] = min_uv

        island_info.append(info)

    return island_info
Esempio n. 21
0
def __get_island_info(uv_layer, islands):
    """
    get information about each island
    """

    island_info = []
    for isl in islands:
        info = {}
        max_uv = Vector((-10000000.0, -10000000.0))
        min_uv = Vector((10000000.0, 10000000.0))
        ave_uv = Vector((0.0, 0.0))
        num_uv = 0
        for face in isl:
            n = 0
            a = Vector((0.0, 0.0))
            ma = Vector((-10000000.0, -10000000.0))
            mi = Vector((10000000.0, 10000000.0))
            for l in face['face'].loops:
                uv = l[uv_layer].uv
                ma.x = max(uv.x, ma.x)
                ma.y = max(uv.y, ma.y)
                mi.x = min(uv.x, mi.x)
                mi.y = min(uv.y, mi.y)
                a = a + uv
                n = n + 1
            ave_uv = ave_uv + a
            num_uv = num_uv + n
            a = a / n
            max_uv.x = max(ma.x, max_uv.x)
            max_uv.y = max(ma.y, max_uv.y)
            min_uv.x = min(mi.x, min_uv.x)
            min_uv.y = min(mi.y, min_uv.y)
            face['max_uv'] = ma
            face['min_uv'] = mi
            face['ave_uv'] = a
        ave_uv = ave_uv / num_uv

        info['center'] = ave_uv
        info['size'] = max_uv - min_uv
        info['num_uv'] = num_uv
        info['group'] = -1
        info['faces'] = isl
        info['max'] = max_uv
        info['min'] = min_uv

        island_info.append(info)

    return island_info
Esempio n. 22
0
    def modal(self, context, event):
        props = context.scene.tom_props
        prefs = context.user_preferences.addons[__name__].preferences

        # 3Dビューの画面を更新
        if context.area:
            context.area.tag_redraw()

        # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了
        if event.type == 'Q' and event.value == 'PRESS':
            props.running = False
            print("サンプル3-10: 通常モードへ移行しました。")
            return {'FINISHED'}

        if event.value == 'PRESS':
            value = Vector((0.0, 0.0, 0.0))
            if event.type == prefs.x_axis:
                value.x = 1.0 if not event.shift else -1.0
            if event.type == prefs.y_axis:
                value.y = 1.0 if not event.shift else -1.0
            if event.type == prefs.z_axis:
                value.z = 1.0 if not event.shift else -1.0
            # 選択中のオブジェクトを並進移動する
            bpy.ops.transform.translate(value=value)

        return {'RUNNING_MODAL'}
Esempio n. 23
0
def calculate_bbox(verts, matrix=None):
    mapped_verts = verts
    if matrix is not None:
        mapped_verts = map(lambda v, M=matrix: M @ v, verts)

    bbox_min = Vector(next(mapped_verts))
    bbox_max = bbox_min.copy()

    for v in mapped_verts:
        if v.x < bbox_min.x:
            bbox_min.x = v.x
        if v.y < bbox_min.y:
            bbox_min.y = v.y
        if v.z < bbox_min.z:
            bbox_min.z = v.z

        if v.x > bbox_max.x:
            bbox_max.x = v.x
        if v.y > bbox_max.y:
            bbox_max.y = v.y
        if v.z > bbox_max.z:
            bbox_max.z = v.z

    # Return bounding box verts
    return bbox_min, bbox_max
Esempio n. 24
0
def relocate(context, isVertical, padding, all_ob_bounds, ob_num=0):

    if ob_num > 0:
        if len(all_ob_bounds[ob_num]) > 0:
            offset = 0.0
            origin = Vector((0, 0))
            for i in range(0, ob_num):
                if len(all_ob_bounds[i]) > 0:
                    if isVertical:
                        offset += all_ob_bounds[i]['height'] + padding
                    else:
                        offset += all_ob_bounds[i]['width'] + padding
            for i in range(0, ob_num + 1):
                if len(all_ob_bounds[i]) > 0:
                    origin.x = all_ob_bounds[i]['min'].x
                    origin.y = all_ob_bounds[i]['max'].y
                    break

            delta = Vector((origin.x - all_ob_bounds[ob_num]['min'].x,
                            origin.y - all_ob_bounds[ob_num]['max'].y))
            if isVertical:
                bpy.ops.transform.translate(value=(delta.x, delta.y - offset,
                                                   0))
            else:
                bpy.ops.transform.translate(value=(delta.x + offset, delta.y,
                                                   0))
Esempio n. 25
0
def saveVertex(fh, fnormal, useSmooth, uvLayer, vtx, vInx, ofst, exportType):
    uv = Vector((0.0, 1.0))
    normal = Vector((fnormal.x, fnormal.y, fnormal.z))
    weights = (0.0, 0.0, 0.0, 0.0)
    co = vtx.co - ofst

    if uvLayer != None:
        uv.x = uvLayer.uv_raw[vInx * 2 + 0]
        uv.y = -uvLayer.uv_raw[vInx * 2 + 1]

    if useSmooth:
        normal = vtx.normal

    rotationMatrix = Matrix.Rotation(math.radians(-90.0), 3, "X")

    co = rotationMatrix * co
    normal = rotationMatrix * normal

    if exportType == eTypes.TYPE0:
        saveVertexType0(fh, co, uv)
    elif exportType == eTypes.TYPE1:
        saveVertexType1(fh, co, normal, uv)
    elif exportType == eTypes.TYPE2:
        saveVertexType2(fh, co, normal, uv, weights)
    elif exportType == eTypes.TYPE3:
        saveVertexType3(fh, co, normal, uv)
    elif exportType == eTypes.TYPE4:
        saveVertexType4(fh, co, normal, uv, weights)
Esempio n. 26
0
 def CarPosRot(Car):
     Offset = Car + 184
     # m = [
     #     [SHAR.read_float(Offset), SHAR.read_float(Offset + 4), SHAR.read_float(Offset + 8), SHAR.read_float(Offset + 12)],
     #     [SHAR.read_float(Offset + 16), SHAR.read_float(Offset + 20), SHAR.read_float(Offset + 24), SHAR.read_float(Offset + 28)],
     #     [SHAR.read_float(Offset + 32), SHAR.read_float(Offset + 36), SHAR.read_float(Offset + 40), SHAR.read_float(Offset + 44)],
     #     [SHAR.read_float(Offset + 48), SHAR.read_float(Offset + 52), SHAR.read_float(Offset + 56), SHAR.read_float(Offset + 60)]
     #     ]
     rot = [
         [
             SHAR.read_float(Offset),
             SHAR.read_float(Offset + 4),
             SHAR.read_float(Offset + 8)
         ],
         [
             SHAR.read_float(Offset + 16),
             SHAR.read_float(Offset + 20),
             SHAR.read_float(Offset + 24)
         ],
         [
             SHAR.read_float(Offset + 32),
             SHAR.read_float(Offset + 36),
             SHAR.read_float(Offset + 40)
         ],
     ]
     rot = Matrix(rot).to_quaternion()
     rot.y, rot.z = rot.z, rot.y
     rot = rot.to_euler()
     pos = Vector(
         (SHAR.read_float(Offset + 48), SHAR.read_float(Offset + 52),
          SHAR.read_float(Offset + 56)))
     pos.y, pos.z = pos.z, pos.y
     return pos, rot
Esempio n. 27
0
def viewDir(dis_v, ang_v):
    """Converts Distance and Angle to View Oriented Vector.

    Converts View Transformation Matrix to Rotational Matrix (3x3)
    Angles are converted to Radians from degrees.

    Args:
        dis_v: Scene distance
        ang_v: Scene angle

    Returns:
        World Vector.
    """

    areas = [a for a in bpy.context.screen.areas if a.type == "VIEW_3D"]
    if len(areas) > 0:
        vm = areas[0].spaces.active.region_3d.view_matrix
        vm = vm.to_3x3().normalized().inverted()
        vl = Vector((0, 0, 0))
        vl.x = dis_v * cos(ang_v * pi / 180)
        vl.y = dis_v * sin(ang_v * pi / 180)
        vw = vm @ vl
        return vw
    else:
        return Vector((0, 0, 0))
Esempio n. 28
0
def sRGB2linear(rgb):
    a = 0.055
    lrgb = Vector()
    lrgb.x = s2lin(rgb.x)
    lrgb.y = s2lin(rgb.y)
    lrgb.z = s2lin(rgb.z)
    return lrgb
    def modal(self, context, event):
        props = context.scene.tom_props
# @include-source start [get_prefs]
        prefs = context.user_preferences.addons[__name__].preferences
# @include-source end [get_prefs]

        # 3Dビューの画面を更新
        if context.area:
            context.area.tag_redraw()

        # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了
        if event.type == 'Q' and event.value == 'PRESS':
            props.running = False
            print("サンプル3-10: 通常モードへ移行しました。")
            return {'FINISHED'}

# @include-source start [refer_prefs]
        if event.value == 'PRESS':
            value = Vector((0.0, 0.0, 0.0))
            if event.type == prefs.x_axis:
                value.x = 1.0 if not event.shift else -1.0
            if event.type == prefs.y_axis:
                value.y = 1.0 if not event.shift else -1.0
            if event.type == prefs.z_axis:
                value.z = 1.0 if not event.shift else -1.0
            # 選択中のオブジェクトを並進移動する
            bpy.ops.transform.translate(value=value)
# @include-source end [refer_prefs]

        return {'RUNNING_MODAL'}
    def modal(self, context, event):
        props = context.scene.tom_props

        # 3Dビューの画面を更新
        if context.area:
            context.area.tag_redraw()

        # キーボードのQキーが押された場合は、オブジェクト並進移動モードを終了
        if event.type == 'Q' and event.value == 'PRESS':
            props.running = False
            print("サンプル3-2: 通常モードへ移行しました。")
            return {'FINISHED'}

        if event.value == 'PRESS':
            value = Vector((0.0, 0.0, 0.0))
            if event.type == 'X':
                value.x = 1.0 if not event.shift else -1.0
            if event.type == 'Y':
                value.y = 1.0 if not event.shift else -1.0
            if event.type == 'Z':
                value.z = 1.0 if not event.shift else -1.0
            # 選択中のオブジェクトを並進移動する
            bpy.ops.transform.translate(value=value)

        return {'RUNNING_MODAL'}
Esempio n. 31
0
def read_vector4(io_stream):
    vec = Vector((0, 0, 0, 0))
    vec.x = read_float(io_stream)
    vec.y = read_float(io_stream)
    vec.z = read_float(io_stream)
    vec.w = read_float(io_stream)
    return vec
Esempio n. 32
0
	def update(self, ctx, clickcount, dimantion):
		dim = dimantion
		if self.shift:
			index = -1 if len(self.subclass.knots) < 2 else -2
			lastpoint = self.subclass.knots[index].pos
			dim.view = get_axis_constraint(lastpoint, dim.view)

		if self.drag:
			pos = self.subclass.knots[-1].pos
			outvec = dim.view
			invec = Vector((0,0,0))
			invec.x = pos.x - (outvec.x - pos.x)
			invec.y = pos.y - (outvec.y - pos.y)
			invec.z = pos.z - (outvec.z - pos.z)
			newknot = knot(pos, invec, outvec, 'ALIGNED')
		else:
			newknot = knot(dim.view, dim.view, dim.view, "VECTOR")

		if clickcount != self.lastclick:
			self.subclass.knots.append(newknot)
			self.lastclick = clickcount
			check_for_close(self, ctx)

		if LineData.close:
			self.subclass.knots.pop()
			self.subclass.close = True
			self.forcefinish = True

		self.subclass.knots[-1] = newknot
		self.subclass.lastknot = [knot(dim.view, dim.view, dim.view, "VECTOR")]

		self.subclass.update(ctx)
def find_HalfExtent_scale(loc):
    scale = Vector()
    values = loc.find("*[@Name='HalfExtents']").attrib
    scale.x = float(values['X'])
    scale.y = float(values['Z'])
    scale.z = float(values['Y'])
    return scale
def item_to_vector(item):
    """Converts XML item object to vector. SWAPS Y and Z"""
    v = Vector()
    v.x = float(item.attrib['X'])
    v.y = float(item.attrib['Z'])
    v.z = float(item.attrib['Y'])
    return v
Esempio n. 35
0
 def render(self):
     diameter = 4.0
     sz = 2.125 / diameter
     base_object = helpers.infer_primitive(random.choice(self.PRIMITIVES),
                                           location=(100, 100, 100),
                                           radius=sz)
     latitude = 16
     longitude = latitude * 2
     invlatitude = 1.0 / (latitude - 1)
     invlongitude = 1.0 / (longitude - 1)
     iprc = 0.0
     jprc = 0.0
     phi = 0.0
     theta = 0.0
     invfcount = 1.0 / (self.NUMBER_OF_FRAMES - 1)
     # Animate center of the sphere.
     center = Vector((0.0, 0.0, 0.0))
     startcenter = Vector((0.0, -4.0, 0.0))
     stopcenter = Vector((0.0, 4.0, 0.0))
     # Rotate cubes around the surface of the sphere.
     pt = Vector((0.0, 0.0, 0.0))
     rotpt = Vector((0.0, 0.0, 0.0))
     # Change the axis of rotation for the point.
     baseaxis = Vector((0.0, 1.0, 0.0))
     axis = Vector((0.0, 0.0, 0.0))
     # Slerp between two rotations for each cube.
     startrot = Quaternion((0.0, 1.0, 0.0), pi)
     stoprot = Quaternion((1.0, 0.0, 0.0), pi * 1.5)
     currot = Quaternion()
     for i in range(0, latitude, 1):
         iprc = i * invlatitude
         phi = pi * (i + 1) * invlatitude
         rad = 0.01 + sz * abs(sin(phi)) * 0.99
         pt.z = cos(phi) * diameter
         for j in range(0, longitude, 1):
             jprc = j * invlongitude
             theta = TWOPI * j / longitude
             pt.y = center.y + sin(phi) * sin(theta) * diameter
             pt.x = center.x + sin(phi) * cos(theta) * diameter
             current = helpers.duplicate_object(base_object)
             current.location = pt
             current.name = 'Object ({0:0>2d}, {1:0>2d})'.format(i, j)
             current.data.name = 'Mesh ({0:0>2d}, {1:0>2d})'.format(i, j)
             current.rotation_euler = (0.0, phi, theta)
             helpers.assign_material(
                 current, helpers.random_material(self.MATERIALS_NAMES))
             axis = self.vecrotatex(theta, baseaxis)
             currot = startrot
             center = startcenter
             for f in range(0, self.NUMBER_OF_FRAMES, 1):
                 fprc = f / (self.NUMBER_OF_FRAMES - 1)
                 osc = abs(sin(TWOPI * fprc))
                 bpy.context.scene.frame_set(f)
                 center = startcenter.lerp(stopcenter, osc)
                 current.location = helpers.rotate_vector(
                     TWOPI * fprc, axis, pt)
                 current.keyframe_insert(data_path='location')
                 currot = startrot.slerp(stoprot, jprc * fprc)
                 current.rotation_euler = currot.to_euler()
                 current.keyframe_insert(data_path='rotation_euler')
def align_island_simple(obj,
                        bm,
                        uv_layers,
                        faces,
                        x=0,
                        y=1,
                        flip_x=False,
                        flip_y=False):

    # Find lowest and highest verts
    minmax_val = [0, 0]
    minmax_vert = [None, None]

    axis_names = ['x', 'y', 'z']
    print("Align shell {}x 	at {},{} flip {},{}".format(
        len(faces), axis_names[x], axis_names[y], flip_x, flip_y))

    # Collect UV to Vert
    vert_to_uv = {}
    face = faces[0]
    for loop in face.loops:
        vert = loop.vert
        uv = loop[uv_layers]
        vert_to_uv[vert] = [uv]
        uv.select = True

    edge = faces[0].edges[0]
    delta = edge.verts[0].co - edge.verts[1].co
    max_side = max(abs(delta.x), abs(delta.y), abs(delta.z))

    # Check edges dominant in active axis
    if abs(delta[x]) == max_side or abs(delta[y]) == max_side:
        uv0 = vert_to_uv[edge.verts[0]][0]
        uv1 = vert_to_uv[edge.verts[1]][0]

        delta_verts = Vector((edge.verts[1].co[x] - edge.verts[0].co[x],
                              edge.verts[1].co[y] - edge.verts[0].co[y]))
        if flip_x:
            delta_verts.x = -edge.verts[1].co[x] + edge.verts[0].co[x]
        if flip_y:
            delta_verts.y = -edge.verts[1].co[y] + edge.verts[0].co[y]

        delta_uvs = Vector((uv1.uv.x - uv0.uv.x, uv1.uv.y - uv0.uv.y))

        a0 = math.atan2(delta_verts.y, delta_verts.x)
        a1 = math.atan2(delta_uvs.y, delta_uvs.x)

        a_delta = math.atan2(math.sin(a0 - a1), math.cos(a0 - a1))

    print("Turn {:.1f}".format(a_delta * 180 / math.pi))

    bpy.ops.uv.select_all(action='DESELECT')
    for face in faces:
        for loop in face.loops:
            loop[uv_layers].select = True

    bpy.context.tool_settings.transform_pivot_point = 'MEDIAN_POINT'
    bpy.ops.transform.rotate(
        value=-a_delta, orient_axis='Z'
    )  # minus angle; Blender uses unconventional rotation notation (positive for clockwise)
Esempio n. 37
0
def view_dir(dis_v, ang_v):
    """Converts Distance and Angle to View Oriented Vector.

    Note:
        Converts View Transformation Matrix to Rotational Matrix (3x3)
        Angles are Converts to Radians from degrees.

    Args:
        dis_v: Scene PDT distance
        ang_v: Scene PDT angle

    Returns:
        World Vector.
    """

    areas = [a for a in bpy.context.screen.areas if a.type == "VIEW_3D"]
    if len(areas) > 0:
        view_matrix = areas[0].spaces.active.region_3d.view_matrix
        view_matrix = view_matrix.to_3x3().normalized().inverted()
        view_location = Vector((0, 0, 0))
        view_location.x = dis_v * cos(ang_v * pi / 180)
        view_location.y = dis_v * sin(ang_v * pi / 180)
        new_view_location = view_matrix @ view_location
        return new_view_location

    return Vector((0, 0, 0))
def get_min_max(vertList):
    min = Vector(vertList[0])
    max = Vector(vertList[0])
    for v in vertList:
        if v.x < min.x:
            min.x = v.x
        elif v.x > max.x:
            max.x = v.x
        if v.y < min.y:
            min.y = v.y
        elif v.y > max.y:
            max.y = v.y
        if v.z < min.z:
            min.z = v.z
        elif v.z > max.z:
            max.z = v.z
    return min, max
def find_xyz(loc, valname):
    """returns vector named valname in loc"""
    v = Vector()
    values = loc.find(f"*[@Name='{valname}']").attrib
    v.x = float(values['X'])
    v.y = float(values['Z'])
    v.z = float(values['Y'])
    return v
def find_xyz_from_mat(loc, mat_name):
    """returns xyz from matrix named mat_name in loc"""
    a = Vector()
    values = loc.find(f"*[@Name='{mat_name}']").attrib
    a.x = float(values['M41'])
    a.y = float(values['M43'])
    a.z = float(values['M42'])
    return a
Esempio n. 41
0
def gui_space(p):
    p = Vector(p).copy()
    
    p.x = p.x*16 - 8
    p.y = p.y*9 - 4.5
    
    p.y *= -1
    
    return p
Esempio n. 42
0
    def shade(self, stroke):
        it = stroke.stroke_vertices_begin()
        if it.is_end:
            return
        p_min = it.object.point.copy()
        p_max = it.object.point.copy()
        while not it.is_end:
            p = it.object.point
            if p.x < p_min.x:
                p_min.x = p.x
            if p.x > p_max.x:
                p_max.x = p.x
            if p.y < p_min.y:
                p_min.y = p.y
            if p.y > p_max.y:
                p_max.y = p.y
            it.increment()
        stroke.resample(32 * self.__turns)
        sv_nb = stroke.stroke_vertices_size()
#       print("min  :", p_min.x, p_min.y) # DEBUG
#       print("mean :", p_sum.x, p_sum.y) # DEBUG
#       print("max  :", p_max.x, p_max.y) # DEBUG
#       print("----------------------") # DEBUG
#######################################################
        sv_nb = sv_nb // self.__turns
        center = (p_min + p_max) / 2
        radius = (center.x - p_min.x + center.y - p_min.y) / 2
        p_new = Vector((0.0, 0.0))
#######################################################
        R = self.__random_radius
        C = self.__random_center
        i = 0
        it = stroke.stroke_vertices_begin()
        for j in range(self.__turns):
            prev_radius = radius
            prev_center = center
            radius = radius + randint(-R, R)
            center = center + Vector((randint(-C, C), randint(-C, C)))
            while i < sv_nb and not it.is_end:
                t = float(i) / float(sv_nb - 1)
                r = prev_radius + (radius - prev_radius) * t
                c = prev_center + (center - prev_center) * t
                p_new.x = c.x + r * cos(2 * pi * t)
                p_new.y = c.y + r * sin(2 * pi * t)
                it.object.point = p_new
                i = i + 1
                it.increment()
            i = 1
        verticesToRemove = []
        while not it.is_end:
            verticesToRemove.append(it.object)
            it.increment()
        for sv in verticesToRemove:
            stroke.remove_vertex(sv)
        stroke.update_length()
Esempio n. 43
0
    def __get_island_info(self, uv_layer, islands):
        """
        get information about each island
        """

        island_info = []
        for isl in islands:
            info = {}
            max_uv = Vector((-10000000.0, -10000000.0))
            min_uv = Vector((10000000.0, 10000000.0))
            ave_uv = Vector((0.0, 0.0))
            num_uv = 0
            for face in isl:
                n = 0
                a = Vector((0.0, 0.0))
                for l in face['face'].loops:
                    uv = l[uv_layer].uv
                    if uv.x > max_uv.x:
                        max_uv.x = uv.x
                    if uv.y > max_uv.y:
                        max_uv.y = uv.y
                    if uv.x < min_uv.x:
                        min_uv.x = uv.x
                    if uv.y < min_uv.y:
                        min_uv.y = uv.y
                    a = a + uv
                    n = n + 1
                ave_uv = ave_uv + a
                num_uv = num_uv + n
                a = a / n
                face['ave_uv'] = a
            ave_uv = ave_uv / num_uv

            info['center'] = ave_uv
            info['size'] = max_uv - min_uv
            info['num_uv'] = num_uv
            info['group'] = -1
            info['faces'] = isl

            island_info.append(info)
        
        return island_info
Esempio n. 44
0
 def __neg__(self):
     """ return antipodal point """
     coo=Vector()
     if self.co.x > 0:
         coo.x = self.co.x -  math.pi
     else:
         coo.x = self.co.x + math.pi
     coo.y = abs(math.pi - self.co.y)
     coo.z = -self.co.z
     return Reflection(co=coo,
             normalize=False)
Esempio n. 45
0
    def _move(self, direction, value):
        """ Moves view into direction by value. """

        for view in self.get3DView():
            offset = Vector((0.0, 0.0, 0.0))
            if direction == "horizontal":
                offset.x = value
            elif direction == "vertical":
                offset.y = value
            elif direction == "straightforward":
                offset.z = value

            view.view_location = view.view_rotation*offset + view.view_location
Esempio n. 46
0
    def getDimensions(self):
        highest = Vector((-10000, -10000, -10000))
        lowest  = Vector(( 10000,  10000,  10000))

        for bone in self.bones:
            if highest.x < bone.restHead.x: highest.x = bone.restHead.x
            if highest.y < bone.restHead.y: highest.y = bone.restHead.y
            if highest.z < bone.restHead.z: highest.z = bone.restHead.z

            if highest.x < bone.restTail.x: highest.x = bone.restTail.x
            if highest.y < bone.restTail.y: highest.y = bone.restTail.y
            if highest.z < bone.restTail.z: highest.z = bone.restTail.z

            if lowest .x > bone.restHead.x: lowest .x = bone.restHead.x
            if lowest .y > bone.restHead.y: lowest .y = bone.restHead.y
            if lowest .z > bone.restHead.z: lowest .z = bone.restHead.z

            if lowest .x > bone.restTail.x: lowest .x = bone.restTail.x
            if lowest .y > bone.restTail.y: lowest .y = bone.restTail.y
            if lowest .z > bone.restTail.z: lowest .z = bone.restTail.z

        return Vector((highest.x - lowest.x, highest.y - lowest.y, highest.z - lowest.z))
    def staticAvoidanceVector(self,playerPos):
        '''find an avoidance vector for static objects in scene

        Parameters:
        playerPos -- the 3D Vector of the player's position
       
        Returns:
        2D Vector describing a way to avoid the static 
        objects in the scene (fences, houses, trees,...)
        '''
        p1 = playerPos.copy()
        p1.z = 0
        result = Vector((0,0,0))
        for v in self.obstacles:
            p2 = v.copy()
            p2.z = 0
            dist = (p1 - p2).magnitude
            angle = atan2(p1.y - p2.y,p1.x - p2.x)
            
            if 0 < dist < 2*self.r1:
                size = 2/dist**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)

        for v in self.bigObstacles:
            p2 = v.copy()
            p2.z = 0
            dist = (p1 - p2).magnitude
            angle = atan2(p1.y - p2.y,p1.x - p2.x)
            
            if 3*self.r1 < dist < 6*self.r1:
                size = 2/(dist-2*self.r1)**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)
            elif self.r1 < dist <= 3*self.r1:
                size = 2/dist**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)
            elif dist < self.r1:
                size = 10/dist**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)

        for v in self.fences:
            p2 = v.copy()
            p2.z = 0
            dist = (p1 - p2).magnitude
            angle = atan2(p1.y - p2.y,p1.x - p2.x)
            
            if self.r1 < dist < 3*self.r1:
                size = 2/dist**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)
            elif 0 < dist <= self.r1:
                size = 10/dist**2
                result.x = result.x  + size*cos(angle)
                result.y = result.y + size*sin(angle)
        return Vector((result.x,result.y))
Esempio n. 48
0
    def execute(self, context):
        scene = context.scene
        obj = context.active_object
        # check if active object is a mesh object
        if not obj or obj.type != 'MESH':
            self.report({'ERROR'}, "No selected mesh object!")
            return {'CANCELLED'}

        # check if it has one single face
        if len(obj.data.polygons) != 1:
            self.report({'ERROR'}, "The selected mesh object has to have exactly one quad!")
            return {'CANCELLED'}

        rl = scene.lightfield.row_length
        # use a degree angle here
        angle = degrees(scene.lightfield.angle)
        spacing = scene.lightfield.spacing
        # resolution of final renderings
        res = round(scene.render.resolution_x * (scene.render.resolution_percentage / 100.))
        width = self.getWidth(obj)

        # the offset between n pixels on the focal plane
        fplane_offset = (width / res) * spacing

        # vertices for the basemesh
        verts = []
        # the offset vector
        vec = self.getCamVec(obj, angle)
        # lower left coordinates of the grid
        sx = obj.location[0] - fplane_offset * int(rl / 2)
        sy = obj.location[1] - fplane_offset * int(rl / 2)
        z = obj.location[2]
        # position on the focal plane
        fplane_pos = Vector()
        for x in [sx + fplane_offset * i for i in range(rl)]:
            for y in [sy + fplane_offset * i for i in range(rl)]:
                fplane_pos.x = x
                fplane_pos.y = y
                fplane_pos.z = z
                # position of a vertex in a basemesh
                pos = fplane_pos + vec
                # pack coordinates flat into the vert list
                verts.append((pos.x, pos.y, pos.z))

        # setup the basemesh and add verts
        mesh = bpy.data.meshes.new(self.objName)
        mesh.from_pydata(verts, [], [])
        self.addMeshObj(mesh)

        return {'FINISHED'}
Esempio n. 49
0
    def _frames_difference_vector(self, frames, attr_func):
        """ Calculates the difference Vector of attribute on the first and the last frame. """

        res = Vector((0.0, 0.0, 0.0))
        for i in (0, -1):
            #get attributes from frames[i]
            v = attr_func(frames[i])
            if i == 0:
                res.y -= v.y
                res.x -= v.x
                res.z -= v.z
            else:
                res.y += v.y
                res.x += v.x
                res.z += v.z

            if res.x > settings.max_x and res.x < -settings.max_x:
                res.y = 0
            if res.y > settings.max_y and res.y < -settings.max_y:
                res.y = 0
            if res.z > settings.max_z and res.z < -settings.max_z:
                res.z = 0
        return res
Esempio n. 50
0
def Translate(mesh, vtx_weight_dict, shapekey_out, dx, dy, dz):
    # Purpose: translate vertices in the weight dict somewhere
    verts = shapekey_out.data
    vwd = vtx_weight_dict
    
    d = Vector((0,0,0))
    
    for i in range(len(verts)):
        if i in vwd:
            d.x = dx
            d.y = dy
            d.z = dz
            verts[i].co += vwd[i] * d
        else:
            continue
Esempio n. 51
0
    def __get_y_axis_align_diff_uvs(self, loop_seqs, uv_layer, uv_min,
                                    width, height):
        diff_uvs = []
        for hidx, hseq in enumerate(loop_seqs):
            pair = hseq[0]
            luv0 = pair[0][uv_layer]
            luv1 = pair[1][uv_layer]
            target_uv0 = Vector((0.0, 0.0))
            target_uv1 = Vector((0.0, 0.0))
            if self.location == 'RIGHT_BOTTOM':
                target_uv0.x = target_uv1.x = uv_min.x + width
            elif self.location == 'MIDDLE':
                target_uv0.x = target_uv1.x = uv_min.x + width * 0.5
            elif self.location == 'LEFT_TOP':
                target_uv0.x = target_uv1.x = uv_min.x
            if luv0.uv.y < luv1.uv.y:
                target_uv0.y = uv_min.y + hidx * height / len(loop_seqs)
                target_uv1.y = uv_min.y + (hidx + 1) * height / len(loop_seqs)
            else:
                target_uv0.y = uv_min.y + (hidx + 1) * height / len(loop_seqs)
                target_uv1.y = uv_min.y + hidx * height / len(loop_seqs)
            diff_uvs.append([target_uv0 - luv0.uv, target_uv1 - luv1.uv])

        return diff_uvs
Esempio n. 52
0
 def get_motion_range(cls, obj):
     """Returns a range vector giving the frame range in which the object has motion
     """
     
     range = Vector((1000000, -1000000))
     
     while obj:
         
         if obj.animation_data and obj.animation_data.action:
             range.x = min(range.x, obj.animation_data.action.frame_range[0])
             range.y = max(range.y, obj.animation_data.action.frame_range[1])
         
         obj = obj.parent
     
     return range
def position_frame_bottom_left(node_tree, frame_node):
    newpos = Vector((100000, 100000))  # start reasonably far top / right

    # Align with the furthest left
    for node in node_tree.nodes.values():
        if node != frame_node and node.parent != frame_node:
            newpos.x = min(newpos.x, node.location.x + 30)

    # As high as we can get without overlapping anything to the right
    for node in node_tree.nodes.values():
        if node != frame_node and not node.parent:
            if node.location.x < newpos.x + frame_node.width:
                print("Below", node.name, node.location, node.height, node.dimensions)
                newpos.y = min(newpos.y, node.location.y - max(node.dimensions.y, node.height) - 20)

    frame_node.location = newpos
Esempio n. 54
0
def saveVertex(fh, obj, fnormal, useSmooth, uvLayer, vtx, vInx):
    uv = Vector((0.0, 1.0))
    normal = Vector((fnormal.x, fnormal.y, fnormal.z))
    weights = (0.0, 0.0, 0.0, 0.0)
    co = obj.location + vtx.co;

    co.x = -co.x

    if uvLayer != None:
        uv.x = uvLayer.uv_raw[vInx * 2 + 0]
        uv.y = -uvLayer.uv_raw[vInx * 2 + 1]

    if useSmooth:
        normal = vtx.normal

    normal.x = -normal.x

    saveVertexType4(fh, co, normal, uv, weights)
Esempio n. 55
0
	def calcBranch(self, branch, angle=0):
		rotation = uniform(0, pi * 2)
		br = copy(branch) 
		a = br.a
		o = Vector([uniform(-1,1),uniform(-1,1),uniform(-1,1)]) 
		if a.x != 0:
			o.x = -(a.y * o.y + a.z * o.z) / a.x
		elif a.y != 0:
			o.y = -(a.x * o.x + a.z * o.z) / a.y
		elif a.z != 0:
			o.z = -(a.x * o.x + a.y * o.y) / a.z
		else:
			raise Exception("Invalid input: zero vector")
		o = norm(o)
		assert(inner_product(o) > .9999 or inner_product(o) < 1.0001)
		assert(o * a < 0.0001)
		br.a = rotation_mat(branch.a, rotation) * (rotation_mat(o, angle) * br.a)
		br.a = norm(vec_vec_mult(br.a, self.gradual_angle))
		return br
Esempio n. 56
0
    def resize_primary_brush(self, radius):
        context = bpy.context
        primary_brush = self.primary_brush
        region_height = context.region.height
        region_width = context.region.width

        # Determine the world space radius of the primary brush necessary to
        # project a circle onto the view plane with the specified region space
        # radius.

        # Determine the z-depth of the primary brush's center in normalized
        # device coordinates.
        projection_matrix = context.region_data.perspective_matrix
        co = primary_brush.center.copy()
        co.resize(4)
        co.w = 1
        co.xyzw = projection_matrix * co
        w = co.w
        co.xyz /= w
        NDC_z_depth = co.z

        # Determine the region space coordinates of the primary brush's center.
        region_x = (co.x + 1) * region_width / 2
        region_y = (co.y + 1) * region_height / 2

        # Determine the NDC coordinates of a point on the edge of the
        # circle that should result from projecting the brush onto the view
        # plane.
        co = Vector((region_x, region_y)) + Vector((radius, 0))

        co.x = co.x * 2 / region_width - 1
        co.y = co.y * 2 / region_height - 1
        co.resize(3)
        co.z = NDC_z_depth

        # Calculate the world space radius of the primary brush.
        co.resize(4)
        co.w = 1
        co.xyzw = projection_matrix.inverted() * co
        w = co.w
        co.resize(3)
        co.xyz /= w
        primary_brush.radius = (co - primary_brush.center).length
Esempio n. 57
0
def texture_update_mapping(self, context):
    if not hasattr(context, "material") or not context.material:
        return
    mat = context.material
    node_name = "%s.%s:mapping" % (mat.name, self.name)
    sel_name = "%s.%s:select" % (mat.name, self.name)
    nodes = mat.node_tree.nodes
    scale = Vector(self.scale)
    offset = Vector(self.offset)
    if node_name in nodes:
        if self.tex in bpy.data.images:
            img = bpy.data.images[self.tex]
            if img.muimageprop.invertY:
                scale.y *= -1
                offset.y = 1 - offset.y
        nodes[node_name].translation.xy = offset
        nodes[node_name].scale.xy = scale
    if sel_name in nodes:
        nodes[sel_name].inputs[0].default_value = float(self.rgbNorm)
Esempio n. 58
0
def node_settex(name, matprops, nodes, s):
    n = nodes["%s.%s" % (name, s[1])]
    tex = matprops.texture.properties[s[3]]
    #FIXME doesn't work
    #offset = tex.offset / tex.scale
    #offset = Vector((tex.offset.x/tex.scale.x, tex.offset.y / tex.scale.y))
    offset = Vector(tex.offset)
    scale = Vector(tex.scale)
    rgbNorm = tex.rgbNorm
    if len(s) > 5:
        val = "%s(%s)" % (s[5], s[4])
    else:
        val = s[4]
    if tex.tex in bpy.data.images:
        tex = bpy.data.images[tex.tex]
        if tex.muimageprop.invertY:
            scale.y *= -1
            offset.y = 1 - offset.y
        cmd = "n.%s = %s" % (s[2], val)
        exec(cmd, {}, locals())
Esempio n. 59
0
    def to_bl_obj(self):
        "Convert this hardpoint to a Blender object."
        import bpy
        from mathutils import Matrix, Vector
        bl_obj = bpy.data.objects.new("hp-" + self.name, None)
        bl_obj.empty_draw_type = "ARROWS"

        matrix_rot = Matrix(self.rot_matrix).to_4x4()

        # Convert position/rotation from WC
        euler_rot = matrix_rot.to_euler("XYZ")
        euler_rot.y, euler_rot.z = -euler_rot.z, -euler_rot.y
        euler_rot.x *= -1

        matrix_rot = euler_rot.to_matrix().to_4x4()
        vector_loc = Vector(self.location)
        vector_loc.y, vector_loc.z = vector_loc.z, vector_loc.y
        matrix_loc = Matrix.Translation(vector_loc)

        bl_obj.matrix_basis = matrix_loc * matrix_rot
        return bl_obj
Esempio n. 60
0
    def apply_location(self, user):
        for joint in user.joints.values():
            for obj in bpy.data.objects:
                if obj.type != "ARMATURE":
                    continue
                armature = obj
                if not armature.pose:
                    continue
                pose = armature.pose
                if not pose.bones:
                    continue
                bones = pose.bones
                if joint.name not in bones:
                    continue
                bone = bones[joint.name]
                if not bone:
                    continue

                location = Vector()
                location.x = joint.location.x
                location.y = joint.location.y
                location.z = joint.location.z

                parent = bone
                while not hasattr(parent, "parent"):
                    parent = parent.parent
                    if not parent:
                        continue
                    if not hasattr(parent, "location"):
                        continue
                    location.x -= parent.location.x
                    location.y -= parent.location.y
                    location.z -= parent.location.z

                bone.location = location

                if bpy.amk2b.recording_started:
                    bone.keyframe_insert(data_path="location", frame=bpy.context.scene.frame_current)