Python Vector.w方法代码示例

# 需要导入模块: from mathutils import Vector [as 别名]
# 或者: from mathutils.Vector import w [as 别名]
def calculate_tangent_space(vertex, uv_layer):
	vertex_tangent = Vector((0.0, 0.0, 0.0, 0.0))
	vertex_bitangent = Vector((0.0, 0.0, 0.0, 0.0))

	# Accumulate faceted tangents
	for i in range(len(vertex.link_faces)):
		face = vertex.link_faces[i]

		position0 = face.loops[0].vert.co
		position1 = face.loops[1].vert.co
		position2 = face.loops[2].vert.co

		uv0 = face.loops[0][uv_layer].uv
		uv1 = face.loops[1][uv_layer].uv
		uv2 = face.loops[2][uv_layer].uv

		position_edge1 = position1 - position0
		position_edge2 = position2 - position0
		uv_edge1 = uv1 - uv0
		uv_edge2 = uv2 - uv0

		inverseDet = uv_edge1.x * uv_edge2.y - uv_edge1.y * uv_edge2.x
		if inverseDet != 0.0:
			inverseDet = 1.0 / inverseDet

		vertex_tangent.xyz += (position_edge1 * uv_edge2.y - position_edge2 * uv_edge1.y) * inverseDet
		vertex_bitangent.xyz += (position_edge2 * uv_edge1.x - position_edge1 * uv_edge2.x) * inverseDet
	
	# Gram-Schmidt orthogonalize
	n = vertex.normal
	t = vertex_tangent.xyz.copy()
	b = vertex_bitangent.xyz.copy()
	n_dot_t = n.dot(t)

	vertex_tangent.xyz = (t - n * n_dot_t).normalized()
	vertex_bitangent.xyz = (b - n * n_dot_t).normalized()

	handedness = -1.0 if (n.cross(t).dot(b) < 0.0) else 1.0
	vertex_tangent.w = handedness
	vertex_bitangent.w = handedness

	return (vertex_tangent, vertex_bitangent)

# 需要导入模块: from mathutils import Vector [as 别名]
# 或者: from mathutils.Vector import w [as 别名]
    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

# 需要导入模块: from mathutils import Vector [as 别名]
# 或者: from mathutils.Vector import w [as 别名]
    def discard_outside_of_view(self, view): 
        # Assume that the mesh object's bounding box is fully contained in the
        # view projection, and test this assumption.
        bounding_box = mesh_object.bound_box
        bounding_box_contained_in_projection = True

        # Transform the coordinates of each vertex of the bounding box from
        # object space to clip space.  As soon as any single vertex is
        # found to be outside of the view projection, duly indicate, and exit
        # the loop.
        projection_matrix = view.projection_matrix
        for vertex in bounding_box:
            co = Vector(vertex)
            co.resize(4)
            co.w = 1
            co.xyzw = projection_matrix * co
            w = co.w

            # Determine if the coordinates are within the view projection.
            if abs(co.x) > w or\
               abs(co.y) > w or\
               abs(co.z) > w:
                bounding_box_contained_in_projection = False
                break

        # If the bounding box is not entirely contained within the view
        # projection then some vertices may exist outside of the view
        # projection.
        if not bounding_box_contained_in_projection: 
            clip_space_map = self.coordinate_map

            # Retain each clip space vertex that is inside of the view
            # projection.
            indices = self.indices
            self.indices = [
                index
                for index in indices
                if abs(clip_space_map[index].x) < clip_space_map[index].w and\
                   abs(clip_space_map[index].y) < clip_space_map[index].w and\
                   abs(clip_space_map[index].z) < clip_space_map[index].w
            ] 

# 需要导入模块: from mathutils import Vector [as 别名]
# 或者: from mathutils.Vector import w [as 别名]
def main(filename):
    sce = bpy.context.scene
    obs = sce.objects
    dfaces = {}
    f = open(filename, 'w')
    f.write('<?xml version="1.0" encoding="utf-8"?>\n<scene>\n\t<directionalLight>\n\t\t<color r="255" g="255" b="255"/>\n\t\t<direction x="-1" y="-1" z="-1"/>\n\t</directionalLight>\n\t<ambientLight>\n\t\t<color r="255" g="255" b="255"/>\n\t</ambientLight>\n')
    for ob in obs:
        if ob.type == 'CAMERA':
            camz = Vector().to_4d()
            camy = Vector().to_4d()
            camy.y = 1
            camy.w = 0
            camz.z = -10
            #camz.w = 0
            target = ob.matrix_world * camz
            normal = ob.matrix_world*camy
            f.write('\t<camera>\n')
            f.write('\t\t<position x="%f" y="%f" z="%f"/>\n' %(ob.location.x, ob.location.y, ob.location.z))
            f.write('\t\t<target x="%f" y="%f" z="%f"/>\n' %(target.x, target.y, target.z))
            f.write('\t\t<normal x="%f" y="%f" z="%f"/>' % (normal.x, normal.y, normal.z))
            f.write('\n\t\t<viewplane w="16/2" h="9/2" d="%f"/>\n\t</camera>\n' %(ob.data.lens/4))
        if ob.type == 'MESH':        
            dfaces = {}
            mesh = ob.data
            verts = mesh.vertices
            ob_mat = ob.matrix_world
            scale = Matrix()
            scale[0][0] = ob.scale.x
            scale[1][1] = ob.scale.y
            scale[2][2] = ob.scale.z
            verts = [ob_mat * scale * vert.co.to_4d() for vert in verts]
            faces = mesh.polygons
            for face in faces:
                material = Material()
                
                if len(ob.material_slots) > 0:
                    #print("index", face.material_index)
                    mat = ob.material_slots[face.material_index].material
                    if mat.use_vertex_color_paint:
                        material.color = mesh.vertex_colors[0].data[face.index].color1
                    else:
                        material.color = mat.diffuse_color
                        if mat.use_transparency:
                            material.transparency= mat.raytrace_transparency.fresnel_factor
                        if mat.use_raytrace:
                            material.reflexivity = mat.raytrace_mirror.reflect_factor
                            material.ambiant     = mat.ambient
                            material.diffuse     = mat.diffuse_intensity
                            material.specular    = mat.specular_intensity
                            material.shininess   = mat.specular_hardness
                if not material in dfaces:
                    dfaces[material] = []
                dfaces[material].append(face)
                
            for material in dfaces:
                f.write("\t<object>\n")
                f.write('\t\t<shape>\n')
                f.write('\t\t\t<list>\n')
                for face in dfaces[material]:
                    vs = face.vertices                    
                    if len(vs)==3:
                        writeTriangle(f, mesh.vertices, verts, vs, material)
                    elif len(vs)==4:
                        vs1 = vs[:3]
                        vs2 = [vs[0],vs[2], vs[3]]
                        writeTriangle(f, mesh.vertices, verts, vs1, material)
                        writeTriangle(f, mesh.vertices, verts, vs2, material)
                    else:
                        print("Pas de face")
                        
                f.write('\t\t\t</list>\n')
                f.write('\t\t</shape>\n')
                f.write('\t\t<material>\n\t\t\t<phong>\n')
                f.write('\t\t\t\t<color r="%d" g="%d" b="%d"/>\n' % (int(255*material.color.r), int(255*material.color.g), int(255*material.color.b)))
                f.write('\t\t\t\t<specular v="%f"/>\n' % (material.specular))
                f.write('\t\t\t\t<diffuse v="%f"/>\n' % (material.diffuse))
                f.write('\t\t\t\t<ambiant v="%f"/>\n' % (material.ambiant))
                f.write('\t\t\t\t<shininess v="%f"/>\n' % (material.shininess))
                f.write('\t\t\t\t<reflexivity v="%f"/>\n' % (material.reflexivity))
                f.write('\t\t\t\t<transparency v="%f"/>\n' % (material.transparency))
                f.write('\t\t\t</phong>\n\t\t</material>\n')
                f.write("\t</object>\n")
    
    f.write("</scene>")
    f.close()          
    print ("\nExport to PRay xml completed.")
    return {'FINISHED'}        

# 需要导入模块: from mathutils import Vector [as 别名]
# 或者: from mathutils.Vector import w [as 别名]
    def stroke(self, region_x, region_y):
        props = self.props
        brushes = props.brushes
        derived_brushes = brushes.derived_brushes
        primary_brush = brushes.primary_brush

        active_object = bpy.context.active_object
        indices_affected_by_stroke = self.indices_affected_by_stroke
        vertices = active_object.data.vertices

        # The primary brush must be on the mesh in order to execute a stroke.
        if not primary_brush.is_on_mesh:
            return

        # Only proceed if at least one vertex is affected by the stroke.
        if not indices_affected_by_stroke:
            return

        # Determine the terminal position of the stroke in world space
        # coordinates.
        inverted_perspective_matrix =\
            bpy.context.region_data.perspective_matrix.inverted()
        co = Vector((region_x, region_y))
        co.x = co.x * 2 / bpy.context.region.width - 1
        co.y = co.y * 2 / bpy.context.region.height - 1
        co.resize(4)
        co.z = self.stroke_z_depth
        co.w = 1
        co = inverted_perspective_matrix * co
        w = co.w
        co.resize(3)
        co /= w
        stroke_terminal_co = co

        # Apply the stroke to each brush.
        inverted_model_matrix = active_object.matrix_world.inverted()
        for brush in [primary_brush] + brushes.derived_brushes:
            # Determine the displaced position of the brush caused by the
            # stroke.
            displaced_brush_center =\
                brush.transformation_matrix * stroke_terminal_co

            # Calculate an object space displacement vector between the brush's
            # original position and its displaced position.
            object_space_displacement = (
                inverted_model_matrix *  displaced_brush_center -
                inverted_model_matrix * brush.center
            )

            # Move the brush to its displaced position.
            brush.center = displaced_brush_center

            # Add the displacement vector to the coordinates of the brush's
            # affected vertices, taking into account brush falloff.
            falloff_map = brush.falloff_map
            for index in brush.indices:
                vertices[index].co +=\
                    falloff_map[index] * object_space_displacement

        # Constrain the vertices to the specified target, if necessary.
        if self.target:
            surface_constraint_props = self.surface_constraint_props
            apply_shrinkwrap(
                offset = self.offset, target = self.target,
                wrap_method = surface_constraint_props.wrap_method_map[
                    surface_constraint_props.direction
                ],
                affected_indices = list(indices_affected_by_stroke)
            )

        # Update the octree's coordinate map.
        model_matrix = active_object.matrix_world
        world_space_submap = {
            index : model_matrix * vertices[index].co
            for index in indices_affected_by_stroke
        }
        self.props.octree.coordinate_map.update(world_space_submap)