Struct Sketch

pub struct Sketch {
    pub id: Uuid,
    pub paths: Vec<Path>,
    pub on: SketchSurface,
    pub start: BasePath,
    pub tags: IndexMap<String, TagIdentifier>,
    pub artifact_id: ArtifactId,
    pub original_id: Uuid,
    pub units: UnitLen,
    pub meta: Vec<Metadata>,
}

A sketch is a collection of paths.

When you define a sketch to a variable like:

mySketch = startSketchOn('XY')
    |> startProfileAt([-12, 12], %)
    |> line(end = [24, 0])
    |> line(end = [0, -24])
    |> line(end = [-24, 0])
    |> close()

The mySketch variable will be an executed Sketch object. Executed being past tense, because the engine has already executed the commands to create the sketch.

The previous sketch commands will never be executed again, in this case.

If you would like to encapsulate the commands to create the sketch any time you call it, you can use a function.

fn createSketch() {
   return startSketchOn('XY')
        |> startProfileAt([-12, 12], %)
        |> line(end = [24, 0])
        |> line(end = [0, -24])
        |> line(end = [-24, 0])
        |> close()
}

Now, every time you call createSketch(), the commands will be executed and a new sketch will be created.

When you assign the result of createSketch() to a variable (mySketch = createSketch()), you are assigning the executed sketch to that variable. Meaning that the sketch mySketch will not be executed again.

You can still execute new commands on the sketch like extrude, revolve, loft, etc. and the sketch will be updated.

Fields

id: Uuid

The id of the sketch (this will change when the engine’s reference to it changes).

paths: Vec<Path>

The paths in the sketch.

on: SketchSurface

What the sketch is on (can be a plane or a face).

start: BasePath

The starting path.

tags: IndexMap<String, TagIdentifier>

Tag identifiers that have been declared in this sketch.

artifact_id: ArtifactId

The original id of the sketch. This stays the same even if the sketch is is sketched on face etc.

original_id: Uuid

units: UnitLen

meta: Vec<Metadata>

Metadata.

Trait Implementations

impl Clone for Sketch

fn clone(&self) -> Sketch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sketch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Sketch

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Sketch> for Vec<Box<Sketch>>

fn from(sg: &Sketch) -> Self

Converts to this type from the input type.

impl<'a> FromKclValue<'a> for Sketch

fn from_kcl_val(arg: &'a KclValue) -> Option<Self>

Try to convert a KclValue into this type.

impl JsonSchema for Sketch

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Sketch

fn eq(&self, other: &Sketch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Sketch

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TS for Sketch

const DOCS: Option<&'static str>

JSDoc comment to describe this type in TypeScript - when TS is derived, docs are automatically read from your doc comments or #[doc = ".."] attributes

type WithoutGenerics = Sketch

If this type does not have generic parameters, then WithoutGenerics should just be Self. If the type does have generic parameters, then all generic parameters must be replaced with a dummy type, e.g ts_rs::Dummy or (). The only requirement for these dummy types is that EXPORT_TO must be None.

fn ident() -> String

Identifier of this type, excluding generic parameters.

fn name() -> String

Name of this type in TypeScript, including generic parameters

fn decl_concrete() -> String

Declaration of this type using the supplied generic arguments. The resulting TypeScript definition will not be generic. For that, see TS::decl(). If this type is not generic, then this function is equivalent to TS::decl().

fn decl() -> String

Declaration of this type, e.g. type User = { user_id: number, ... }. This function will panic if the type has no declaration.

fn inline() -> String

Formats this types definition in TypeScript, e.g { user_id: number }. This function will panic if the type cannot be inlined.

fn inline_flattened() -> String

Flatten a type declaration.
This function will panic if the type cannot be flattened.

fn visit_generics(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all type parameters of this type.

fn output_path() -> Option<&'static Path>

Returns the output path to where T should be exported.
The returned path does not include the base directory from TS_RS_EXPORT_DIR.

fn visit_dependencies(v: &mut impl TypeVisitor)

where Self: 'static,

Iterates over all dependency of this type.

fn dependencies() -> Vec<Dependency>

where Self: 'static,

Resolves all dependencies of this type recursively.

fn export() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem. To export this type together with all of its dependencies, use TS::export_all.

fn export_all() -> Result<(), ExportError>

where Self: 'static,

Manually export this type to the filesystem, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export.

fn export_all_to(out_dir: impl AsRef<Path>) -> Result<(), ExportError>

where Self: 'static,

Manually export this type into the given directory, together with all of its dependencies.
To export only this type, without its dependencies, use TS::export.

fn export_to_string() -> Result<String, ExportError>

where Self: 'static,

Manually generate bindings for this type, returning a String.
This function does not format the output, even if the format feature is enabled.

fn default_output_path() -> Option<PathBuf>

Returns the output path to where T should be exported.

impl StructuralPartialEq for Sketch