Function bodies 257 total

    def build_material_data(material)
      data = { name: material.name, display_name: material.display_name }

      if material.color
        data[:color] = {
          red: material.color.red, green: material.color.green,
          blue: material.color.blue, alpha: material.alpha
        }
      end

    def build_camera_info_response(model)
      camera = model.active_view.camera
      eye = camera.eye
      target = camera.target
      up = camera.up

      {
        success: true,
        eye: [eye.x, eye.y, eye.z],
        target: [target.x, target.y, target.z],
        up: [up.x, up.y, up.z],
        fov: camera.fov,
        aspect_ratio: camera.aspect_ratio,
        perspective: camera.perspective?
      }
    end

    def determine_screenshot_path(output_path)
      if output_path
        path = File.expand_path(output_path)
        FileUtils.mkdir_p(File.dirname(path))
        path
      else
        screenshots_dir = File.join(File.dirname(__FILE__), '..', '..', '..', '.tmp', 'screenshots')
        FileUtils.mkdir_p(screenshots_dir)
        timestamp = Time.now.strftime('%Y%m%d-%H%M%S')
        File.join(screenshots_dir, "screenshot-#{timestamp}.png")
      end

    def write_screenshot(model, screenshot_path, params)
      width = params['width'] || 1920
      height = params['height'] || 1080

      options = {
        filename: screenshot_path, width: width, height: height,
        antialias: true, compression: 0.9, transparent: params['transparent'] || false
      }

      model.active_view.write_image(options)

      {
        success: true, file_path: screenshot_path, file_name: File.basename(screenshot_path),
        width: width, height: height, format: 'png',
        message: "Screenshot saved to #{screenshot_path}. Use Read tool to view if needed."
      }
    end

    def perform_save(model, path)
      if path
        model.save(path)
        path
      else
        model.save
        model.path
      end

    def self.bounds_to_hash(bounds)
      {
        min: [bounds.min.x, bounds.min.y, bounds.min.z],
        max: [bounds.max.x, bounds.max.y, bounds.max.z],
        center: [bounds.center.x, bounds.center.y, bounds.center.z]
      }
    end

    def self.show_console
      SKETCHUP_CONSOLE.show
    rescue StandardError
      begin
        Sketchup.send_action('showRubyPanel:')
      rescue StandardError
        UI.start_timer(0) { SKETCHUP_CONSOLE.show }
      end

    def self.create_circle_points(center, radius, segments = 24)
      points = []
      segments.times do |i|
        angle = Math::PI * 2 * i / segments
        x = center[0] + (radius * Math.cos(angle))
        y = center[1] + (radius * Math.sin(angle))
        z = center[2]
        points << [x, y, z]
      end

    def self.create_success_response(request, result)
      {
        jsonrpc: request['jsonrpc'] || '2.0',
        result: result,
        id: request['id']
      }
    end

    def self.create_error_response(request, error_message, error_code = -32_603, data = nil)
      error_data = data || { success: false }
      error_data[:success] = false unless error_data.key?(:success)

      {
        jsonrpc: request['jsonrpc'] || '2.0',
        error: {
          code: error_code,
          message: error_message,
          data: error_data
        },
        id: request['id']
      }
    end

    def components(color)
      {
        r: color.red,
        g: color.green,
        b: color.blue,
        a: color.alpha
      }
    end

    def erase(definition)
      definition.instances.each(&:erase!)

      # Erasing all entities purges the definition from the model.
      # Must be done within an operation for safety.
      definition.entities.clear!

      nil
    end

    def place_axes(definition, new_axes, adjust_instances = true)
      definition.entities.transform_entities(
        new_axes.inverse,
        definition.entities.to_a
      )

      if adjust_instances
        definition.instances.each do |instance|
          instance.transformation *= new_axes
        end

    def unique_to?(definition, scopes)
      raise ArgumentError, 'Expected ComponentDefinition.' unless definition.is_a?(Sketchup::ComponentDefinition)

      scopes = [scopes] unless scopes.is_a?(Array)
      raise ArgumentError, 'Scope is empty.' if scopes.empty?

      # Get all instance paths for this definition
      all_paths = all_instance_paths(definition)

      all_paths.all? do |path|
        scopes.any? { |scope| instance_path_matches_scope?(path, scope) }
      end

    def all_instance_paths(definition)
      paths = []

      definition.instances.each do |instance|
        collect_paths_to_instance(instance, [], paths)
      end

    def collect_paths_to_instance(instance, current_path, paths)
      new_path = current_path + [instance]

      parent = instance.parent
      if parent.is_a?(Sketchup::ComponentDefinition)
        if parent.instances.empty?
          # Definition is in model root
          paths << new_path
        else
          parent.instances.each do |parent_instance|
            collect_paths_to_instance(parent_instance, new_path, paths)
          end

    def instance_path_matches_scope?(path, scope)
      case scope
      when Sketchup::ComponentDefinition
        path.any? do |instance|
          Entity.instance?(instance) && Entity.definition(instance) == scope
        end

    def midpoint(edge)
      ::Geom.linear_combination(
        0.5,
        edge.start.position,
        0.5,
        edge.end.position
      )
    end

    def swap_definition(instance, new_definition)
      if instance.is_a?(Sketchup::Group) || new_definition.group?
        old_instance = instance
        instance = old_instance.parent.entities.add_instance(
          new_definition,
          old_instance.transformation
        )
        instance.material = old_instance.material
        instance.layer = old_instance.layer
        instance.hidden = old_instance.hidden?
        copy_attributes(instance, old_instance)
        old_instance.erase!
      else
        instance.definition = new_definition
      end

    def copy_attributes(target, source)
      dicts = source.attribute_dictionaries || []

      dicts.each do |dict|
        next if dict.name == CREDITS_DICT

        dict.each_pair do |key, value|
          target.set_attribute(dict.name, key, value)
        end

    def has_dictionary?(entity, dict_name)
      dicts = entity.attribute_dictionaries
      return false if dicts.nil?

      dicts.any? { |dict| dict.name == dict_name }
    end

    def dictionary_names(entity)
      dicts = entity.attribute_dictionaries
      return [] if dicts.nil?

      dicts.map(&:name)
    end

    def arbitrary_interior_point(face)
      return nil if face.area.zero?

      # In rare situations polygon_points_at returns collinear points,
      # which would lead to a point on the boundary. Loop until we find
      # non-collinear points.
      index = 1
      points = nil
      loop do
        points = face.mesh.polygon_points_at(index)
        index += 1
        break unless points[0].on_line?([points[1], points[2]])
      end

    def includes_point?(face, point, include_boundary = true)
      pc = face.classify_point(point)
      return include_boundary if [Sketchup::Face::PointOnEdge, Sketchup::Face::PointOnVertex].include?(pc)

      pc == Sketchup::Face::PointInside
    end

    def triangulate(face, transformation = IDENTITY)
      mesh = face.mesh
      indices = mesh.polygons.flatten.map(&:abs)
      points = indices.map { |i| mesh.point_at(i) }
      points.each { |pt| pt.transform!(transformation) }

      points.each_slice(3).to_a
    end

    def wrapping_face(face)
      edge_faces = face.edges.map(&:faces)
      return nil if edge_faces.empty?

      common_faces = edge_faces.inject(:&)
      return nil if common_faces.nil?

      (common_faces - [face]).first
    end

      def center
        return nil if empty?

        if is_2d?
          # Center of 4 points
          x = @points.sum(&:x) / 4.0
          y = @points.sum(&:y) / 4.0
          z = @points.sum(&:z) / 4.0
        else
          # Center of 8 points
          x = @points.sum(&:x) / 8.0
          y = @points.sum(&:y) / 8.0
          z = @points.sum(&:z) / 8.0
        end

      def direction_internal
        second = at(1)
        if second.is_a?(::Geom::Vector3d)
          second.normalize
        elsif second.is_a?(Array) && second.size == 3
          ::Geom::Vector3d.new(second).normalize
        else
          # Assume second is a point, compute vector from first to second
          at(0).vector_to(second).normalize
        end

      def normal(plane)
        raise ArgumentError, "Object doesn't represent a plane." unless valid?(plane)

        return plane[1].normalize if plane.size == 2

        a, b, c = plane
        ::Geom::Vector3d.new(a, b, c).normalize
      end

      def point(plane)
        raise ArgumentError, "Object doesn't represent a plane." unless valid?(plane)

        return plane[0] if plane.size == 2

        a, b, c, d = plane
        v = ::Geom::Vector3d.new(a, b, c)
        ORIGIN.offset(v, -d)
      end

      def parallel?(plane_a, plane_b)
        raise ArgumentError, "Object 'plane_a' doesn't represent a plane." unless valid?(plane_a)
        raise ArgumentError, "Object 'plane_b' doesn't represent a plane." unless valid?(plane_b)

        normal(plane_a).parallel?(normal(plane_b))
      end

      def same?(plane_a, plane_b, include_flipped = false)
        raise ArgumentError, "Object 'plane_a' doesn't represent a plane." unless valid?(plane_a)
        raise ArgumentError, "Object 'plane_b' doesn't represent a plane." unless valid?(plane_b)

        return false unless point(plane_a).on_plane?(plane_b)
        return false unless parallel?(plane_a, plane_b)

        include_flipped || normal(plane_a).samedirection?(normal(plane_b))
      end

      def transform(plane, transformation)
        raise ArgumentError, "Object doesn't represent a plane." unless valid?(plane)
        raise ArgumentError, 'Requires transformation.' unless transformation.is_a?(::Geom::Transformation)

        [
          point(plane).transform(transformation),
          Vector.transform_as_normal(normal(plane), transformation)
        ]
      end

      def valid?(plane)
        return false unless plane.is_a?(Array)

        (plane.size == 4 && plane.all? { |e| e.is_a?(Numeric) }) ||
          (plane.size == 2 && valid_point?(plane[0]) && valid_vector?(plane[1]))
      end

      def between?(point, boundary_a, boundary_b, include_boundaries = true)
        return false unless point.on_line?([boundary_a, boundary_b])

        vector_a = point - boundary_a
        vector_b = point - boundary_b

        # Point is on one of the boundaries
        return include_boundaries if !vector_a.valid? || !vector_b.valid?

        # Point is between if vectors point in opposite directions
        !vector_a.samedirection?(vector_b)
      end

      def front_of_plane?(point, plane)
        # Get plane normal (handle both plane formats)
        normal = if plane.size == 2
                   plane[1].normalize
                 else
                   # [a, b, c, d] format - normal is [a, b, c]
                   ::Geom::Vector3d.new(plane[0], plane[1], plane[2]).normalize
                 end

    def mid_point(*args)
      case args.size
      when 1 # Edge
        points = args.first.vertices.map(&:position)
      when 2 # Points
        points = args
      else
        raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
      end

    def polygon_area(points)
      origin = points.first
      normal = polygon_normal(points)

      area = 0
      points.each_with_index do |pt0, i|
        pt1 = points[i + 1] || points.first
        triangle_area = ((pt1 - pt0) * (origin - pt0)).length / 2
        if (pt1 - pt0) * (origin - pt0) % normal > 0
          area += triangle_area
        else
          area -= triangle_area
        end

    def polygon_normal(points)
      normal = ::Geom::Vector3d.new(0, 0, 0)
      points.each_with_index do |pt0, i|
        pt1 = points[i + 1] || points.first
        normal.x = normal.x + (pt0.y - pt1.y) * (pt0.z + pt1.z)
        normal.y = normal.y + (pt0.z - pt1.z) * (pt0.x + pt1.x)
        normal.z = normal.z + (pt0.x - pt1.x) * (pt0.y + pt1.y)
      end

    def angle_in_plane(minuend, subtrahend, normal = Z_AXIS)
      # Project vectors to plane by double cross product
      minuend = normal * minuend * normal
      subtrahend = normal * subtrahend * normal

      # Determine if we need to go the "long way" around
      if (minuend * subtrahend) % normal > 0
        Math::PI * 2 - minuend.angle_between(subtrahend)
      else
        minuend.angle_between(subtrahend)
      end

      def from_euler_angles(origin = ORIGIN, x_angle = 0, y_angle = 0, z_angle = 0)
        ::Geom::Transformation.new(origin) *
          ::Geom::Transformation.rotation(ORIGIN, Z_AXIS, z_angle) *
          ::Geom::Transformation.rotation(ORIGIN, Y_AXIS, y_angle) *
          ::Geom::Transformation.rotation(ORIGIN, X_AXIS, x_angle)
      end

      def euler_angles(transformation)
        a = remove_scaling(remove_shearing(transformation, false)).to_a

        x = Math.atan2(a[6], a[10])
        c2 = Math.sqrt(a[0]**2 + a[1]**2)
        y = Math.atan2(-a[2], c2)
        s = Math.sin(x)
        c1 = Math.cos(x)
        z = Math.atan2(s * a[8] - c1 * a[4], c1 * a[5] - s * a[9])

        [x, y, z]
      end

      def remove_scaling(transformation, allow_flip = false)
        x_axis = xaxis(transformation).normalize
        x_axis = x_axis.reverse if flipped?(transformation) && !allow_flip
        from_axes(
          transformation.origin,
          x_axis,
          yaxis(transformation).normalize,
          zaxis(transformation).normalize
        )
      end

      def remove_shearing(transformation, preserve_determinant = false)
        x = xaxis(transformation)
        y = yaxis(transformation)
        z = zaxis(transformation)

        x_norm = x.normalize
        new_yaxis = x_norm * y * x_norm
        y_norm = new_yaxis.normalize
        new_zaxis = y_norm * (x_norm * z * x_norm) * y_norm

        unless preserve_determinant
          new_yaxis = set_vector_length(new_yaxis, y.length)
          new_zaxis = set_vector_length(new_zaxis, z.length)
        end

      def same?(tr_a, tr_b)
        xaxis(tr_a) == xaxis(tr_b) &&
          yaxis(tr_a) == yaxis(tr_b) &&
          zaxis(tr_a) == zaxis(tr_b) &&
          tr_a.origin == tr_b.origin
      end

      def scale_factor_in_plane(transformation, plane)
        normal = Plane.normal(plane)

        tr = from_axes(
          ORIGIN,
          yaxis(transformation) * zaxis(transformation),
          zaxis(transformation) * xaxis(transformation),
          xaxis(transformation) * yaxis(transformation)
        )

        normal.transform(tr).length.to_f
      end

      def transpose(transformation)
        a = transformation.to_a

        ::Geom::Transformation.new([
                                     a[0], a[4], a[8], 0,
                                     a[1], a[5], a[9], 0,
                                     a[2], a[6], a[10], 0,
                                     0, 0, 0, a[15]
                                   ])
      end

      def set_vector_length(vector, length)
        return vector unless vector.valid?

        normalized = vector.normalize
        ::Geom::Vector3d.new(normalized.x * length, normalized.y * length, normalized.z * length)
      end

      def transform_as_normal(normal, transformation)
        # Get the 3x3 rotation/scale matrix from the transformation
        # and compute its transpose, then inverse, then apply to normal
        #
        # For a pure rotation, transpose = inverse, so this simplifies.
        # For scaling/shearing, we need the full computation.

        # Extract the 3x3 matrix
        a = transformation.to_a
        m = [
          [a[0], a[1], a[2]],
          [a[4], a[5], a[6]],
          [a[8], a[9], a[10]]
        ]

        # Transpose
        mt = [
          [m[0][0], m[1][0], m[2][0]],
          [m[0][1], m[1][1], m[2][1]],
          [m[0][2], m[1][2], m[2][2]]
        ]

        # Create transformation from transposed matrix (at origin)
        tr_t = ::Geom::Transformation.new([
                                            mt[0][0], mt[0][1], mt[0][2], 0,
                                            mt[1][0], mt[1][1], mt[1][2], 0,
                                            mt[2][0], 

      def temp_path
        paths = [
          Sketchup.temp_dir,
          ENV.fetch('TMPDIR', nil),
          ENV.fetch('TMP', nil),
          ENV.fetch('TEMP', nil)
        ]
        temp = paths.find { |path| path && File.exist?(path) }
        raise 'Unable to locate temp directory' if temp.nil?

        File.expand_path(temp)
      end