Class: Sketchup::View

Inherits:
Object
  • Object
show all

Overview

This class contains methods to manipulate the current point of view of the model. The drawing methods here (#draw_line, #draw_polyline, etc) are meant to be invoked within a tool's Tool#draw method. Calling them outside Tool#draw will have no effect.

You access the View by calling the Model#active_view method.

Examples:

view = Sketchup.active_model.active_view

Version:

  • SketchUp 6.0

Constants for View draw and View draw2d # collapse

Sketchup::View::CORNER_TOP_LEFT
Sketchup::View::CORNER_TOP_RIGHT
Sketchup::View::CORNER_BOTTOM_LEFT
Sketchup::View::CORNER_BOTTOM_RIGHT

Instance Method Summary # collapse

Instance Method Details

↑ #add_observer(observer) ⇒ Boolean

The add_observer method is used to add an observer to the current object.

Examples:

view = Sketchup.active_model.active_view
status = view.add_observer observer

Parameters:

  • observer (Object) —

    An observer.

Returns:

  • (Boolean) —

    true if successful, false if unsuccessful.

Version:

  • SketchUp 6.0

↑ #animation=(animation) ⇒ Object

The #animation= method is used to set an animation that is displayed for a view. See Animation for details on how to create an animation object.

Examples:

animation = ViewSpinner.new
model = Sketchup.active_model
view = model.active_view
anim = view.animation = animation

Parameters:

  • animation (#nextFrame)

Version:

  • SketchUp 6.0

↑ #average_refresh_time ⇒ Float

The average_refresh_time is used to set the average time used to refresh the current model in the view. This can be used to estimate the frame rate for an animation.

Examples:

model = Sketchup.active_model
view = model.active_view
time = view.average_refresh_time

Returns:

  • (Float) —

    the time in seconds

Version:

  • SketchUp 6.0

↑ #camera ⇒ Sketchup::Camera

The camera method is used to retrieve the camera for the view.

Examples:

camera = view.camera

Returns:

Version:

  • SketchUp 6.0

↑ #camera=(camera) ⇒ Object #camera=(camera_and_transition) ⇒ Object

The #camera= method is used to set the camera for the view. If a transition time is given, then it will animate the transition from the current camera to the new one.

Examples:

camera = Sketchup::Camera.new([5, 5, 9], [5, 10, 0], Z_AXIS)
view = Sketchup.active_model.active_view
view.camera = camera

Overloads:

  • #camera=(camera) ⇒ Object

    Parameters:

  • #camera=(camera_and_transition) ⇒ Object

    Parameters:

    • camera_and_transition (Array(Sketchup::Camera, Float)) —

      The second item in the array represents the transition time from the existing camera to the new one.

Version:

  • SketchUp 6.0

↑ #center ⇒ Array(Integer, Integer) #center ⇒ Array(Float, Float)

The #center method is used to retrieve the coordinates of the center of the view in pixels.

Examples:

model = Sketchup.active_model
view = model.active_view
center = view.center

Overloads:

  • #center ⇒ Array(Integer, Integer)
    Note:

    Signature for versions prior to SketchUp 2025.0

    Returns Physical pixels.

    Returns:

    • (Array(Integer, Integer)) —

      Physical pixels.

    Version:

    • SketchUp 6.0

  • #center ⇒ Array(Float, Float)

    Returns Logical pixels.

    Returns:

    • (Array(Float, Float)) —

      Logical pixels.

    Version:

    • SketchUp 2025.0

↑ #corner(index) ⇒ Array(Integer, Integer) #corner(index) ⇒ Array(Float, Float)

Note:

If the view uses a Camera with a fixed aspect ratio, then the corners are the corners of the viewing are of the camera which might be different than the actual corners of the view itself.

The #corner method is used to retrieve the coordinates of one of the corners of the view. The argument is an index between 0 and 3 that identifies which corner you want. This method returns an array with two integers which are the coordinates of the corner of the view in the view space.

The indices are as follows:

Examples:

New preferred style using constants

# From SketchUp 2025.0:
point = Sketchup.active_model.active_view.corner(Sketchup::View::CORNER_BOTTOM_LEFT)

Old style using hard coded indices

# For SketchUp 2024.0 and older: (Works with newer versions too)
point = Sketchup.active_model.active_view.corner(2)

Overloads:

  • #corner(index) ⇒ Array(Integer, Integer)
    Note:

    Signature for versions prior to SketchUp 2025.0

    Returns a 2D array [x, y] representing the screen point in physical pixels.

    Parameters:

    • index (Integer) —

      A value between (or including) 0 and 3 identifying the corner whose coordinate you want to retrieve.

    Returns:

    • (Array(Integer, Integer)) —

      a 2D array [x, y] representing the screen point in physical pixels.

    Version:

    • SketchUp 6.0

  • #corner(index) ⇒ Array(Float, Float)

    Returns a 2D array [x, y] representing the screen point in logical pixels.

    Parameters:

    • index (Integer) —

      A value between (or including) 0 and 3 identifying the corner whose coordinate you want to retrieve.

    Returns:

    • (Array(Float, Float)) —

      a 2D array [x, y] representing the screen point in logical pixels.

    Version:

    • SketchUp 2025.0

↑ #device_height ⇒ Integer

The #device_height method is used to retrieve the height of the viewport for the view in physical pixels.

Examples:

model = Sketchup.active_model
view = model.active_view
height = view.device_height

Returns:

  • (Integer) —

    the height of the viewport in physical pixels.

Version:

  • SketchUp 2025.0

↑ #device_width ⇒ Integer

The #device_width method is used to retrieve the width of the viewport for the view in physical pixels.

Examples:

width = view.device_width

Returns:

  • (Integer) —

    the width of the viewport in physical pixels.

Version:

  • SketchUp 2025.0

↑ #draw(openglenum, points) ⇒ Sketchup::View #draw(openglenum, *points) ⇒ Sketchup::View #draw(openglenum, points, **options) ⇒ Sketchup::View #draw(openglenum, *points, **options) ⇒ Sketchup::View

Note:

If you draw outside the model bounds you need to implement Tool#getExtents which returns a bounding box large enough to include the points you draw. Otherwise your drawing will be clipped.

The #draw method is used to do basic drawing. This method can only be called from within the Tool#draw method of a tool that you implement in Ruby.

The following constants are all OpenGL terms and have been externalized to Ruby. Here is a summary of their meanings:

GL_POINTS

Treats each vertex as a single point. Vertex n defines point n. N points are drawn.

GL_LINES

Treats each pair of vertices as an independent line segment. Vertices 2n-1 and 2n define line n. N/2 lines are drawn.

GL_LINE_STRIP

Draws a connected group of line segments from the first vertex to the last. Vertices n and n+1 define line n. N-1 lines are drawn.

GL_LINE_LOOP

Draws a connected group of line segments from the first vertex to the last, then back to the first. Vertices n and n+1 define line n. The last line, however, is defined by vertices N and 1. N lines are drawn.

GL_TRIANGLES

Treats each triplet of vertices as an independent triangle. Vertices 3n-2, 3n-1, and 3n define triangle n. N/3 triangles are drawn.

GL_TRIANGLE_STRIP

Draws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. For odd n, vertices n, n+1, and n+2 define triangle n. For even n, vertices n+1, n, and n+2 define triangle n. N-2 triangles are drawn.

GL_TRIANGLE_FAN

Draws a connected group of triangles. One triangle is defined for each vertex presented after the first two vertices. Vertices 1, n+1, and n+2 define triangle n. N-2 triangles are drawn.

GL_QUADS

Treats each group of four vertices as an independent quadrilateral. Vertices 4n-3, 4n-2, 4n-1, and 4n define quadrilateral n. N/4 quadrilaterals are drawn.

GL_QUAD_STRIP

Draws a connected group of quadrilaterals. One quadrilateral is defined for each pair of vertices presented after the first pair. Vertices 2n-1, 2n, 2n+2, and 2n+1 define quadrilateral n. N/2-1 quadrilaterals are drawn. Note that the order in which vertices are used to construct a quadrilateral from strip data is different from that used with independent data.

GL_POLYGON

Draws a single, convex polygon. Vertices 1 through N define this polygon.

Examples:

points = [
  Geom::Point3d.new(0, 0, 0),
  Geom::Point3d.new(9, 0, 0),
  Geom::Point3d.new(9, 9, 0),
  Geom::Point3d.new(0, 9, 0)
]
view.draw(GL_LINE_LOOP, points)

Overloads:

  • #draw(openglenum, points) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
  • #draw(openglenum, *points) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
  • #draw(openglenum, points, **options) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
    • options (Hash)

    Options Hash (**options):

    • :normals (Array<Geom::Vector3d>) —

      Without normals the polygons will be rendered with flat shading. No light will affect it. By providing an array of vertex normals lighting is turned on and will use the model's current light. Note that the number of normals must match the number of points provided.

    • :texture (Integer) —

      A texture id provided by #load_texture.

    • :uvs (Array<Geom::Vector3d>) —

      Set of UV (Not UVQ) coordinates matching the number of points provided. This must be used along with the :texture option.

    Version:

    • SketchUp 2020.0

  • #draw(openglenum, *points, **options) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
    • options (Hash)

    Options Hash (**options):

    • :normals (Array<Geom::Vector3d>) — default: [] —

      Without normals the polygons will be rendered with flat shading. No light will affect it. By providing an array of vertex normals lighting is turned on and will use the model's current light. Note that the number of normals must match the number of points provided.

    • :texture (Integer) —

      A texture id provided by #load_texture.

    • :uvs (Array<Geom::Vector3d>) —

      Set of UV (Not UVQ) coordinates matching the number of points provided. This must be used along with the :texture option.

    Version:

    • SketchUp 2020.0

Returns:

See Also:

Version:

  • SketchUp 6.0

↑ #draw2d(openglenum, points) ⇒ Sketchup::View #draw2d(openglenum, *points) ⇒ Sketchup::View #draw2d(openglenum, points, **options) ⇒ Sketchup::View #draw2d(openglenum, *points, **options) ⇒ Sketchup::View

Note:

Prior to SketchUp 2025.0 this method accepted the points as physical screen coordinates. As of SketchUp 2025.0 the points are expected to be in logical screen coordinates. Older versions need to apply the scaling factor from UI.scale_factor to the points before passing them to this method.

The #draw2d method is used to draw in screen space (using 2D screen coordinates) instead of 3D space.

The second parameter is an Array of Geom::Point3d objects (or several individual Geom::Point3d objects). These Geom::Point3d objects are in screen space, not 3D space.

The X value corresponds to the number of pixels from the left edge of the drawing area. The Y value corresponds to the number of pixels down from the top of the drawing area. The Z value is not used.

Examples:

points = [
  Geom::Point3d.new(0, 0, 0),
  Geom::Point3d.new(8, 0, 0),
  Geom::Point3d.new(8, 4, 0),
  Geom::Point3d.new(0, 4, 0),
]
view.draw2d(GL_LINE_STRIP, points)

Overloads:

  • #draw2d(openglenum, points) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
  • #draw2d(openglenum, *points) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
  • #draw2d(openglenum, points, **options) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
    • options (Hash)

    Options Hash (**options):

    • :texture (Integer) —

      A texture id provided by #load_texture.

    • :uvs (Array<Geom::Vector3d>) —

      Set of UV (Not UVQ) coordinates matching the number of points provided. This must be used along with the :texture option.

    Version:

    • SketchUp 2020.0

  • #draw2d(openglenum, *points, **options) ⇒ Sketchup::View

    Parameters:

    • openglenum (Integer) —

      The item you are going to draw, one of the constants from the comments, such as GL_LINES.

    • points (Array<Geom::Point3d>)
    • options (Hash)

    Options Hash (**options):

    • :texture (Integer) —

      A texture id provided by #load_texture.

    • :uvs (Array<Geom::Vector3d>) —

      Set of UV (Not UVQ) coordinates matching the number of points provided. This must be used along with the :texture option.

    Version:

    • SketchUp 2020.0

Returns:

See Also:

Version:

  • SketchUp 6.0

↑ #draw_lines(points, ...) ⇒ Sketchup::View #draw_lines(points) ⇒ Sketchup::View

The draw_lines method is used to draw disconnected lines.

You must have an even number of points. This method is usually invoked within the draw method of a tool.

Examples:

point4 = Geom::Point3d.new 0,0,0
point5 = Geom::Point3d.new 100,100,100
# returns a view
status = view.drawing_color="red"
status = view.draw_lines point4, point5

Overloads:

Version:

  • SketchUp 6.0

↑ #draw_lines(points, ...) ⇒ Sketchup::View #draw_lines(points) ⇒ Sketchup::View

The draw_lines method is used to draw disconnected lines.

You must have an even number of points. This method is usually invoked within the draw method of a tool.

Examples:

point4 = Geom::Point3d.new 0,0,0
point5 = Geom::Point3d.new 100,100,100
# returns a view
status = view.drawing_color="red"
status = view.draw_lines point4, point5

Overloads:

Version:

  • SketchUp 6.0

↑ #draw_points(points, size = 6, style = 3, color = 'black') ⇒ Sketchup::View

Note:

Prior to SketchUp 2025.0 this method accepted the size as physical pixels. As of SketchUp 2025.0 the points are expected to be in logical pixels. Older versions need to apply the scaling factor from UI.scale_factor to the size before passing them to this method.

This method is used to draw points in model space.

Examples:

point = Geom::Point3d.new(0, 0, 0)
view.draw_points(point, 10, 1, "red")

Parameters:

  • points (Array<Geom::Point3d>) —

    Model coordinates.

  • size (Integer) (defaults to: 6) —

    Size of the point in pixels.

  • style (Integer) (defaults to: 3) —

    • 1 = open square

    • 2 = filled square

    • 3 = plus shape “+”

    • 4 = cross shape “X”

    • 5 = star shape “*”

    • 6 = open triangle

    • 7 = filled triangle

  • color (Sketchup::Color) (defaults to: 'black')

Returns:

Version:

  • SketchUp 6.0

↑ #draw_polyline(points, ...) ⇒ Sketchup::View #draw_polyline(points) ⇒ Sketchup::View

The draw_polyline method is used to draw a series of connected line segments from pt1 to pt2 to pt3, and so on.

This method is usually invoked within the draw method of a tool.

Examples:

point12 = Geom::Point3d.new 0,0,0
point13 = Geom::Point3d.new 10,10,10
point14 = Geom::Point3d.new 20,20,20
point15 = Geom::Point3d.new 30,30,30
status = view.draw_polyline point12, point13, point14, point15

Overloads:

Version:

  • SketchUp 6.0

↑ #draw_text(point, text) ⇒ Sketchup::View #draw_text(point, text, options = {}) ⇒ Sketchup::View

Note:

Under Windows the font name must be less than 32 characters - due to system limitations.

Note:

As of SU2017 this will automatically scale the font-size by the same factor as UI.scale_factor.

Note:

The font size is platform dependent. On Windows the method expects points, where on Mac it's pixels. See “Cross Platform Font Size” example for details. As of SketchUp 2025.0 you can use the :pixel_size or :point_size options to specify the size in pixels or points respectively.

This method is used to draw text on the screen and is usually invoked within the draw method of a tool.

The TextVerticalAlignCenter option will align the text to the center of the height of the first line, not the whole boundingbox of the text. To align around the full bounds of the text, use #text_bounds to compute the desired alignment.

The vertical alignment can vary between fonts and platforms. It's recommended to test different fonts and find one that fits well across both platforms for your purposes.

Example of different vertical alignment and text bounds:

Examples:

class ExampleTool
  def draw(view)
    # This works in all SketchUp versions and draws the text using the
    # default font, size and color (i.e. the model edge color).
    point = Geom::Point3d.new(200, 100, 0)
    view.draw_text(point, "This is a test")

    # This works in SketchUp 2016 and up.
    options = {
      :font => "Arial",
      :size => 20,
      :bold => true,
      :align => TextAlignRight
    }
    point = Geom::Point3d.new(200, 200, 0)
    view.draw_text(point, "This is another\ntest", options)

    # You can also use Ruby 2.0's named arguments:
    point = Geom::Point3d.new(200, 200, 0)
    view.draw_text(point, "Hello world!", color: "Red")
  end
end

Cross Platform Font Size in SketchUp 2025.0 and newer

class ExampleTool
  def draw(view)
    draw_text(view, [100, 200, 0], "Hello Pixel World", pixel_size: 20)
    draw_text(view, [100, 250, 0], "Hello Point World", point_size: 20)
  end
end

Cross Platform Font Size in SketchUp 2024.0 and older

class ExampleTool
  IS_WIN = Sketchup.platform == :platform_win

  def draw(view)
    draw_text(view, [100, 200, 0], "Hello World", size: 20)
  end

  private

  # This will ensure text is drawn with consistent size across platforms,
  # using pixels as size units.
  def draw_text(view, position, text, **options)
    native_options = options.dup
    if IS_WIN && options.key?(:size)
      native_options[:size] = pixels_to_points(options[:size])
    end
    view.draw_text(position, text, **native_options)
  end

  def pixels_to_points(pixels)
    ((pixels.to_f / 96.0) * 72.0).round
  end
end

Overloads:

  • #draw_text(point, text) ⇒ Sketchup::View

    Parameters:

    • point (Geom::Point3d) —

      A Point3d object representing a 2D coordinate in view space.

    • text (String) —

      The text string to draw.

  • #draw_text(point, text, options = {}) ⇒ Sketchup::View

    Parameters:

    • point (Geom::Point3d) —

      A Point3d object representing a 2D coordinate in view space.

    • text (String) —

      The text string to draw.

    • options (Hash) (defaults to: {}) —

      The text can be customized by providing a hash or named arguments of options.

    Options Hash (options):

    • :font (String) —

      The name of the font to use. If it does not exist on the system, a default font will be used instead.

    • :size (Integer) —

      Legacy: The size of the font in system-dependent units. On Windows this is in points, on Mac it's in pixels.

    • :pixel_size (Integer) —

      Added SketchUp 2025.0: The size of the font in pixels.

    • :point_size (Integer) —

      Added SketchUp 2025.0: The size of the font in points.

    • :bold (Boolean) —

      Controls the Bold property of the font.

    • :italic (Boolean) —

      Controls the Italic property of the font.

    • :color (Sketchup::Color) —

      The color to draw the text with.

    • :align (Integer) —

      The text alignment, one of the following constants: TextAlignLeft, TextAlignCenter or TextAlignRight.

    • :vertical_align (Integer) —

      Added SketchUp 2020.0. The vertical text alignment, one of the following constants: TextVerticalAlignBoundsTop, TextVerticalAlignBaseline, TextVerticalAlignCapHeight or TextVerticalAlignCenter. Note that some fonts on Mac might not align as expected due to the system reporting incorrect font metrics.

    Raises:

    • (ArgumentError) —

      if combining usage of :size, :pixel_size or :point_size options.

    Version:

    • SketchUp 2016

Returns:

See Also:

Version:

  • SketchUp 6.0

Known Bugs:

  • Prior to SU2022.0, on macOS, the vertical text alignment for some fonts could appear to be offset from their expected positions. As of SU2022.0 the vertical alignment should be more accurate and consistent.

↑ #drawing_color=(color) ⇒ Sketchup::View

The drawing_color method is used to set the color that is used for drawing to the view.

This method is usually invoked within the draw method of a tool.

Examples:

view = view.drawing_color = color

Parameters:

Returns:

Version:

  • SketchUp 6.0

↑ #dynamic=(value) ⇒ Boolean

Deprecated.

This method is no longer doing anything.

The dynamic= method allows you to degrade visual quality while improving performance when a model is large and view refresh time is slow. For example, if you were using a Ruby script to animate the camera through a large scene, you may want to set dynamic to true during that time.

See also camera.rb which is part of the film and stage ruby scripts.

Examples:

view.dynamic = true

Parameters:

  • value (Boolean)

Returns:

  • (Boolean)

Version:

  • SketchUp 6.0

↑ #field_of_view ⇒ Float

The field_of_view method is used get the view's field of view setting, in degrees.

Examples:

fov = Sketchup.active_model.active_view.field_of_view

Returns:

  • (Float) —

    the field of view

Version:

  • SketchUp 6.0

↑ #field_of_view=(fov) ⇒ Numeric

The field_of_view= method is used set the view's field of view setting, in degrees.

Examples:

my_view = Sketchup.active_model.active_view
my_view.field_of_view = 45
my_view.invalidate

Parameters:

  • fov (Numeric) —

    the field of view

Returns:

Version:

  • SketchUp 6.0

↑ #graphics_engine ⇒ Symbol

The #graphics_engine method is used query the type of the graphics engine that's currently used by this view.

Examples:

engine = Sketchup.active_model.active_view.graphics_engine
if engine == :graphics_engine_classic
  puts 'Classic graphics engine'
elsif engine == :graphics_engine_2024
  puts 'New graphics engine'
end

Returns:

  • (Symbol) —

    Type of the graphics engine. :graphics_engine_classic or :graphics_engine_2024

Version:

  • SketchUp 2024.0

↑ #guess_target ⇒ Geom::Point3d #guess_target(screen_point) ⇒ Geom::Point3d

The guess_target method is used to guess at what the user is looking at when you have a perspective view.

Examples:

target = view.guess_target

Overloads:

Returns:

  • (Geom::Point3d) —

    a Point3d object representing the point in the model that the user is likely interested in.

Version:

  • SketchUp 6.0

↑ #inference_locked? ⇒ Boolean

The inference_locked? method is used to determine if inference locking is on for the view.

Examples:

model = Sketchup.active_model
view = model.active_view
status = view.inference_locked

Returns:

  • (Boolean)

Version:

  • SketchUp 6.0

↑ #inputpoint(x, y) ⇒ Sketchup::InputPoint #inputpoint(x, y, inputpoint1) ⇒ Sketchup::InputPoint #inputpoint(x, y) ⇒ Sketchup::InputPoint #inputpoint(x, y, inputpoint1) ⇒ Sketchup::InputPoint

The #inputpoint method is used to retrieve an InputPoint.

This will normally be used inside one of the mouse event handling methods in a tool. Usually, it is preferable to create the InputPoint first and then use the pick method on it.

Examples:

class ExampleTool
  def onMouseMove(flags, x, y, view)
    inputpoint = view.inputpoint(x, y)
    instance_path = ip.instance_path
  end
end

Inference from another input point

class ExampleTool

  def onLButtonUp(flags, x, y, view)
    @picked_input = view.inputpoint(x, y)
  end

  def onMouseMove(flags, x, y, view)
    # Note: It is preferrable to initialize input points using
    # Sketchup::InputPoint.new in `initialize` and reuse them doing the
    # picking using the `pick` method.
    if @inputpoint
      @inputpoint = view.inputpoint(x, y, @picked_input)
    else
      @inputpoint = view.inputpoint(x, y)
    end
  end

 def draw(view)
   if @inputpoint
     @inputpoint.draw(view) if @inputpoint.display?
   else
     @picked_input.draw(view) if @picked_input.display?
   end
 end
end

Overloads:

  • #inputpoint(x, y) ⇒ Sketchup::InputPoint
    Note:

    Signature for versions prior to SketchUp 2025.0

    Parameters:

    • x (Integer) —

      Screen coordinate in physical pixels.

    • y (Integer) —

      Screen coordinate in physical pixels.

    Version:

    • SketchUp 6.0

  • #inputpoint(x, y, inputpoint1) ⇒ Sketchup::InputPoint
    Note:

    Signature for versions prior to SketchUp 2025.0

    Parameters:

    • x (Integer) —

      Screen coordinate in physical pixels.

    • y (Integer) —

      Screen coordinate in physical pixels.

    • inputpoint1 (Sketchup::InputPoint)

    Version:

    • SketchUp 6.0

  • #inputpoint(x, y) ⇒ Sketchup::InputPoint

    Parameters:

    • x (Float) —

      Screen coordinate in logical pixels.

    • y (Float) —

      Screen coordinate in logical pixels.

    Version:

    • SketchUp 2025.0

  • #inputpoint(x, y, inputpoint1) ⇒ Sketchup::InputPoint

    Parameters:

    • x (Float) —

      Screen coordinate in logical pixels.

    • y (Float) —

      Screen coordinate in logical pixels.

    • inputpoint1 (Sketchup::InputPoint)

    Version:

    • SketchUp 2025.0

Returns:

↑ #invalidate ⇒ Sketchup::View

Note:

This is the preferred method to update the viewport. Use this before trying to use #refresh.

The invalidate method is used mark the view as in need of a redraw.

Examples:

model = Sketchup.active_model
view = model.active_view
invalidated_view = view.invalidate

Returns:

Version:

  • SketchUp 6.0

↑ #last_refresh_time ⇒ Float #last_refresh_time(full) ⇒ Float

The last_refresh_time method is used to retrieve the time for the last full view refresh.

Examples:

time = view.last_refresh_time

Overloads:

  • #last_refresh_time(full) ⇒ Float

    Parameters:

    • full (Boolean)

Returns:

  • (Float) —

    time in milliseconds

Version:

  • SketchUp 6.0

↑ #line_stipple=(pattern) ⇒ Sketchup::View

The line_stipple= method is used to set the line pattern to use for drawing. The stipple pattern is given as a string. Valid strings are:

"." (Dotted Line),
"-" (Short Dashes Line),
"_" (Long Dashes Line),
"-.-" (Dash Dot Dash Line),
"" (Solid Line).

This method is usually invoked within the draw method of a tool.

Examples:

point8 = Geom::Point3d.new 0,0,0
point9 = Geom::Point3d.new 100,100,100
view.line_stipple = "-.-"
view = view.draw_lines point8, point9

Parameters:

  • pattern (String) —

    A string stipple pattern, such as “-.-”

Returns:

Version:

  • SketchUp 6.0

↑ #line_width=(width) ⇒ Integer

Note:

As of SU2017 this will automatically scale the line width by the same factor as UI.scale_factor.

The line_width= method is used to set the line width to use for drawing. The value is a Double indicating the desired width in pixels.

This method is usually invoked within the draw method of a tool.

Examples:

view.line_width = width

Parameters:

  • width (Integer) —

    The width in pixels.

Returns:

  • (Integer)

Version:

  • SketchUp 6.0

↑ #load_texture(image_rep) ⇒ Integer

Note:

Avoid loading and releasing textures within the Tool#draw event as that is not efficient.

Note:

SketchUp 2020.0-2022.0: To conserve resources on the user's machine, textures can be loaded only when there is a Ruby tool on the tool stack. Make sure to release the texture when it's no longer needed. Any textures not already released when the last Ruby tool on the tool stack is removed will be automatically released by SketchUp. As of SketchUp 2023.0 this automatic cleanup was removed to allow Overlays to draw textures.

Loads a texture to be drawn with #draw or #draw2d.

Examples:

module Example
  class MyTool
    def activate
      view = Sketchup.active_model.active_view
      image_rep = view.model.materials.current.texture.image_rep
      @texture_id = view.load_texture(image_rep)
    end

    def deactivate(view)
      view.release_texture(@texture_id)
    end

    def draw(view)
      points = [ [0, 0, 0], [9, 0, 0], [9, 9, 0], [0, 9, 0] ]
      uvs = [ [0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0] ]
      view.draw(GL_QUADS, points, texture: @texture_id, uvs: uvs)
    end
  end
end
Sketchup.active_model.select_tool(Example::MyTool.new)

Parameters:

Returns:

  • (Integer) —

    A resource ID referring to the image loaded.

Raises:

  • (ArgumentError) —

    if the provided ImageRep is not valid.

  • (RuntimeError) —

    if a Ruby tool was not on the tool stack. (Applies to SketchUp 2020.0-2022.0).

See Also:

Version:

  • SketchUp 2020.0

↑ #lock_inference ⇒ Sketchup::View #lock_inference(inputpoint) ⇒ Sketchup::View #lock_inference(inputpoint, inputpoint2) ⇒ Sketchup::View

The #lock_inference method is used to lock or unlock an inference.

This method will typically be called from inside a tool class when the user presses the shift key or arrow keys.

With no arguments it unlocks all inferences. With one argument it locks inference based on that passed InputPoint's entities, e.g. along a Edge's line or a Face's plane. With two arguments, it locks inference along an axis.

Examples:

view = view.lock_inference
view = view.lock_inference(inputpoint)
view = view.lock_inference(inputpoint1, inputpoint2)

Overloads:

Returns:

Version:

  • SketchUp 6.0

↑ #model ⇒ Sketchup::Model

The model method is used to retrieve the model for the current view.

Examples:

model = view.model

Returns:

Version:

  • SketchUp 6.0

↑ #pick_helper ⇒ Sketchup::PickHelper #pick_helper(x, y, aperture = 0) ⇒ Sketchup::PickHelper #pick_helper(x, y, aperture = 0.0) ⇒ Sketchup::PickHelper

The #pick_helper method is used to retrieve a pick helper for the view.

Examples:

model = Sketchup.active_model
view = model.active_view
ph = view.pick_helper

Overloads:

  • #pick_helper ⇒ Sketchup::PickHelper

    Returns:

  • #pick_helper(x, y, aperture = 0) ⇒ Sketchup::PickHelper
    Note:

    Signature for versions prior to SketchUp 2025.0

    Parameters:

    • x (Integer) —

      Screen coordinate in physical pixels.

    • y (Integer) —

      Screen coordinate in physical pixels.

    • aperture (Integer) (defaults to: 0) —

      The size of the aperture in physical pixels.

    Returns:

    Version:

    • SketchUp 6.0

  • #pick_helper(x, y, aperture = 0.0) ⇒ Sketchup::PickHelper

    Parameters:

    • x (Float) —

      Screen coordinate in logical pixels.

    • y (Float) —

      Screen coordinate in logical pixels.

    • aperture (Float) (defaults to: 0.0) —

      The size of the aperture in logical pixels.

    Returns:

    Version:

    • SketchUp 2025.0

See Also:

Version:

  • SketchUp 6.0

↑ #pickray(screen_point) ⇒ Array(Geom::Point3d, Geom::Vector3d) #pickray(x, y) ⇒ Array(Geom::Point3d, Geom::Vector3d) #pickray(screen_point) ⇒ Array(Geom::Point3d, Geom::Vector3d) #pickray(x, y) ⇒ Array(Geom::Point3d, Geom::Vector3d)

The #pickray method is used to retrieve a ray passing through a given screen position in the viewing direction.

Examples:

ray = view.pickray(x, y)
result = model.raytest(ray)

Overloads:

See Also:

Version:

  • SketchUp 6.0

↑ #pixels_to_model(pixels, point) ⇒ Float

Note:

As of SU2017 this will automatically scale the pixel-size by the same factor as UI.scale_factor.

The #pixels_to_model method is used to compute a model size from a pixel size at a given point.

This method is useful for deciding how big to draw something based on a desired size in pixels.

Examples:

size = view.pixels_to_model(pixels, point)

Parameters:

  • pixels (Numeric) —

    Logical pixels since SketchUp 2017.

  • point (Geom::Point3d) —

    A model point where the size will be calculated from.

Returns:

  • (Float) —

    the model size

Version:

  • SketchUp 6.0

↑ #refresh ⇒ Sketchup::View

Note:

This method might impact performance and if used incorrectly cause instability or crashes. Don't use this unless you have verified that you cannot use #invalidate instead.

The refresh method is used to immediately force a redraw of the view.

Examples:

model = Sketchup.active_model
view = model.active_view
refreshed_view = view.refresh

Returns:

Version:

  • SketchUp 7.1

↑ #release_texture(texture_id) ⇒ Boolean

Releases a texture loaded via #load_texture, freeing up it's memory. It's good practice to do so whenever there is no longer any need for the resource.

For example, when your tool deactivates you probably want to release your resources as you don't know if your tool will be used again.

Examples:

module Example
  class MyTool
    def activate
      view = Sketchup.active_model.active_view
      image_rep = view.model.materials.current.texture.image_rep
      @texture_id = view.load_texture(image_rep)
    end

    def deactivate(view)
      view.release_texture(@texture_id)
    end

    def draw(view)
      points = [ [0, 0, 0], [9, 0, 0], [9, 9, 0], [0, 9, 0] ]
      uvs = [ [0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0] ]
      view.draw(GL_QUADS, points, texture: @texture_id, uvs: uvs)
    end
  end
end
Sketchup.active_model.select_tool(Example::MyTool.new)

Parameters:

  • texture_id (Integer)

Returns:

  • (Boolean) —

    true if texture was released. false otherwise.

See Also:

↑ #remove_observer(observer) ⇒ Boolean

The remove_observer method is used to remove an observer from the current object.

Examples:

view = Sketchup.active_model.active_view
status = view.remove_observer observer

Parameters:

  • observer (Object) —

    An observer.

Returns:

  • (Boolean) —

    true if successful, false if unsuccessful.

Version:

  • SketchUp 6.0

↑ #screen_coords(model_point) ⇒ Geom::Point3d #screen_coords(model_point) ⇒ Geom::Point3d

Note:

Prior to SketchUp 2025.0 this method returned the points as physical screen coordinates. As of SketchUp 2025.0 the points are returned in logical screen coordinates.

The #screen_coords method is used to retrieve the screen coordinates of the given point on the screen.

The x and y values returned correspond to the x and y screen coordinates. Ignore the z values. If the referenced point is not in the current viewport, the x and/or y value may be negative.

Examples:

view = Sketchup.active_model.active_view
point = view.screen_coords(ORIGIN)

Overloads:

  • #screen_coords(model_point) ⇒ Geom::Point3d
    Note:

    Signature for versions prior to SketchUp 2025.0

    Returns Screen coordinate in physical pixels.

    Parameters:

    Returns:

    Version:

    • SketchUp 6.0

  • #screen_coords(model_point) ⇒ Geom::Point3d

    Returns Screen coordinate in logical pixels.

    Parameters:

    Returns:

    Version:

    • SketchUp 2025.0

Version:

  • SketchUp 6.0

↑ #set_color_from_line(point1, point2) ⇒ Sketchup::View

Set the drawing color for the view based on the direction of a line that you want to draw. These colors will match the axes colors in the SketchUp model (typically blue for straight up and down, etc.)

This method is usually invoked within the draw method of a tool.

Examples:

view = view.set_color_from_line point1, point2

Parameters:

  • point1 (Geom::Point3d) —

    Point3d object representing first point in the line.

  • point2 (Geom::Point3d) —

    Point3d object representing the second point in the line.

Returns:

Version:

  • SketchUp 6.0

↑ #show_frame(delay) ⇒ Sketchup::View

The show_frame method is used to show a frame of an Animation object in the current view.

You can supply an optional delay in seconds to wait before showing the next frame. This can be useful to control the speed at which the animation runs.

Examples:

status = view.show_frame delay

Parameters:

  • delay (Numeric) —

    An optional delay in seconds.

Returns:

Version:

  • SketchUp 6.0

↑ #text_bounds(point, text, options = {}) ⇒ Geom::Bounds2d

Note:

Under Windows the font name must be less than 32 characters - due to system limitations.

This method is used to compute the bounds of the text when using #draw_text. The bounds are not a tight fit around the top and bottom as they include varying amount of line spacing depending on the font used.

The TextVerticalAlignCenter option will align the text to the center of the height of the first line, not the whole boundingbox of the text.

Example of different vertical alignment and text bounds:

Examples:

class ExampleTool
  TEXT_OPTIONS = {
    :font => "Arial",
    :pixel_size => 20, # Use :size for SketchUp 2024.0 and older.
    :bold => true,
    :align => TextAlignRight,
    :vertical_align => TextVerticalAlignBaseline
  }

  # Since `draw` is called frequently it can be useful to pre-compute and
  # cache values used by `draw`.
  def activate
    @text = "Hello SketchUp"
    @position = Geom::Point3d.new(200, 200, 0)

    # Compute text bounds
    view = Sketchup.active_model.active_view
    bounds = view.text_bounds(@position, @text, TEXT_OPTIONS)

    # Compute polygon for the text bounds
    x1, y1 = bounds.upper_left.to_a
    x2, y2 = bounds.lower_right.to_a
    @points = [
      Geom::Point3d.new(x1, y1),
      Geom::Point3d.new(x1, y2),
      Geom::Point3d.new(x2, y2),
      Geom::Point3d.new(x2, y1),
    ]
  end

  def draw(view)
    # Draw text bounds
    view.drawing_color = Sketchup::Color.new(255, 0, 0, 64)
    view.draw2d(GL_QUADS, @points)

    # Draw text
    view.draw_text(@position, @text, TEXT_OPTIONS)
  end
end

Parameters:

  • point (Geom::Point3d) —

    A Point3d object representing a 2D coordinate in view space.

  • text (String) —

    The text string to draw.

  • options (Hash) (defaults to: {}) —

    The text can be customized by providing a hash or named arguments of options.

Options Hash (options):

  • :font (String) —

    The name of the font to use. If it does not exist on the system, a default font will be used instead.

  • :size (Integer) —

    Legacy: The size of the font in system-dependent units. On Windows this is in points, on Mac it's in pixels.

  • :pixel_size (Integer) —

    Added SketchUp 2025.0: The size of the font in pixels.

  • :point_size (Integer) —

    Added SketchUp 2025.0: The size of the font in points.

  • :bold (Boolean) —

    Controls the Bold property of the font.

  • :italic (Boolean) —

    Controls the Italic property of the font.

  • :align (Integer) —

    The text alignment, one of the following constants: TextAlignLeft, TextAlignCenter or TextAlignRight.

  • :vertical_align (Integer) —

    The vertical text alignment one of the following constants: TextVerticalAlignBoundsTop, TextVerticalAlignBaseline, TextVerticalAlignCapHeight or TextVerticalAlignCenter.

Raises:

  • (ArgumentError) —

    if combining usage of :size, :pixel_size or :point_size options.

Returns:

See Also:

Version:

  • SketchUp 2020.0

↑ #tooltip=(string) ⇒ String

Set a tooltip to display in the view. This is useful for displaying tooltips in a tool that you write in Ruby.

Examples:

tooltip = view.tooltip = string

Parameters:

  • string (String) —

    The string tooltip.

Returns:

  • (String) —

    the new tooltip string

Version:

  • SketchUp 6.0

↑ #vpheight ⇒ Integer #vpheight ⇒ Float

Note:

Prior to SketchUp 2025.0 this method returned the size as physical screen coordinates. As of SketchUp 2025.0 the size are returned in logical screen coordinates.

The #vpheight method is used to retrieve the height of the viewport for the view.

Examples:

model = Sketchup.active_model
view = model.active_view
height = view.vpheight

Overloads:

  • #vpheight ⇒ Integer
    Note:

    Signature for versions prior to SketchUp 2025.0

    Returns the height of the viewport in physical pixels.

    Returns:

    • (Integer) —

      the height of the viewport in physical pixels.

    Version:

    • SketchUp 6.0

  • #vpheight ⇒ Float

    Returns the height of the viewport in logical pixels.

    Returns:

    • (Float) —

      the height of the viewport in logical pixels.

    Version:

    • SketchUp 2025.0

Version:

  • SketchUp 6.0

↑ #vpwidth ⇒ Integer #vpwidth ⇒ Float

Note:

Prior to SketchUp 2025.0 this method returned the size as physical screen coordinates. As of SketchUp 2025.0 the size are returned in logical screen coordinates.

The #vpwidth method is used to retrieve the width of the viewport for the view.

Examples:

view = Sketchup.active_model.active_view
width = view.vpwidth

Overloads:

  • #vpwidth ⇒ Integer
    Note:

    Signature for versions prior to SketchUp 2025.0

    Returns the width of the viewport in physical pixels.

    Returns:

    • (Integer) —

      the width of the viewport in physical pixels.

    Version:

    • SketchUp 6.0

  • #vpwidth ⇒ Float

    Returns the width of the viewport in logical pixels.

    Returns:

    • (Float) —

      the width of the viewport in logical pixels.

    Version:

    • SketchUp 2025.0

Version:

  • SketchUp 6.0

↑ #write_image(filename, width = view.vpwidth, height = view.vpheight, antialias = false, compression = 1.0) ⇒ Boolean #write_image(options) ⇒ Boolean #write_image(options) ⇒ Boolean

The #write_image method is used to write the current view to an image file.

Supported file types are .png, .jpg, .jpeg, gif, .bmp, .tif. For other file formats available from the GUI in File > Export > 2D Graphics, .e.g .pdf, use Model#export.

Overloads:

  • #write_image(filename, width = view.vpwidth, height = view.vpheight, antialias = false, compression = 1.0) ⇒ Boolean
    Note:

    Prefer the overload with option hash instead of this variant. This overload is not updated with new options.

    Examples:

    filename = File.join(Sketchup.temp_dir, 'example.png')
antialias = false
compression = 0.9
model = Sketchup.active_model
view = model.active_view
view.write_image(filename, 640, 480, antialias, compression)

    Parameters:

    • filename (String) —

      The filename for the saved image

    • width (Integer) (defaults to: view.vpwidth) —

      Width in pixels, defaults to the current viewport width #vpwidth.

    • height (Integer) (defaults to: view.vpheight) —

      Height in pixels, defaults to the current viewport height #vpheight.

    • antialias (Boolean) (defaults to: false)
    • compression (Float) (defaults to: 1.0) —

      Compression factor for JPEG images, between 0.0 and 1.0.

  • #write_image(options) ⇒ Boolean

    Examples:

    options = {
  :filename => File.join(Sketchup.temp_dir, 'example.png'),
  :width => 640,
  :height => 480,
  :antialias => false,
  :compression => 0.9,
  :transparent => true
}
model = Sketchup.active_model
view = model.active_view
view.write_image(options)

    Parameters:

    • options (Hash)

    Options Hash (options):

    • filename (String) —

      The filename for the saved image.

    • width (Integer) — default: #vpwidth —

      Width in pixels (max 16000).

    • height (Integer) — default: #vpheight —

      Height in pixels (max 16000).

    • scale_factor (Float) — default: 1.0 —

      Scaling factor for elements that are viewport dependent, such as text heights, arrow heads, line widths, stipple patterns, etc. (Added in SketchUp 2019.2)

    • antialias (Boolean) — default: false
    • compression (Float) — default: 1.0 —

      Compression factor for JPEG, images between 0.0 and 1.0.

    • transparent (Boolean) — default: false —

      Added in SketchUp 8.

    Version:

    • SketchUp 7

  • #write_image(options) ⇒ Boolean

    It is possible to dump the framebuffer to file by setting :source to :framebuffer. When saving the framebuffer only the following options are valid.

    Examples:

    options = {
  :filename => File.join(Sketchup.temp_dir, 'example.png'),
  :source => :framebuffer,
  :compression => 0.9,
}
model = Sketchup.active_model
view = model.active_view
view.write_image(options)

    Parameters:

    • options (Hash)

    Options Hash (options):

    • filename (String) —

      The filename for the saved image.

    • source (Boolean) — default: :image —

      Set to :framebuffer to dump the current framebuffer.

    • compression (Float) — default: 1.0 —

      Compression factor for JPEG, images between 0.0 and 1.0.

    Version:

    • SketchUp 7

Returns:

  • (Boolean)

Version:

  • SketchUp 6.0

↑ #zoom(zoom_or_ents) ⇒ Sketchup::View

The zoom method is used to zoom in or out by some zoom factor.

Examples:

view = view.zoom factor
view = view.zoom selection
view = view.zoom entity
view = view.zoom array_of_entities

Parameters:

Returns:

Version:

  • SketchUp 6.0

↑ #zoom_extents ⇒ Sketchup::View

The zoom_extents method is used to zoom to the extents about the entire model, as if the user has selected the zoom extents command from the menu.

Examples:

view = Sketchup.active_model.active_view
new_view = view.zoom_extents

Returns:

Version:

  • SketchUp 6.0