Tutorial and changed names #57
@ -108,7 +108,7 @@ fun VisionLayout<Solid>.showcase() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
demo("extrude", "extruded shape") {
|
demo("extrude", "extruded shape") {
|
||||||
extrude {
|
extruded {
|
||||||
shape {
|
shape {
|
||||||
polygon(8, 50)
|
polygon(8, 50)
|
||||||
}
|
}
|
||||||
|
|||||||
BIN
docs/images/polyline-points-2.png
Normal file
BIN
docs/images/polyline-points-2.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
BIN
docs/images/polyline-points.png
Normal file
BIN
docs/images/polyline-points.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.5 KiB |
@ -1,8 +1,8 @@
|
|||||||
|
|
|||||||
# Tutorial
|
# Tutorial
|
||||||
|
|
||||||
#### The main goal of this tutorial is to show all capabilities of ... (this part will be supplemented)
|
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
|
||||||
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
The simple visualization can be made with function `main`. (this part will be supplemented as well)
|
The simple visualization can be made with function `main`. (this part will be supplemented)
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
```kotlin
|
```kotlin
|
||||||
import kotlinx.html.div
|
import kotlinx.html.div
|
||||||
import space.kscience.dataforge.context.Context
|
import space.kscience.dataforge.context.Context
|
||||||
@ -16,12 +16,20 @@ fun main(){
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
}
|
}
|
||||||
|
|
||||||
context.makeVisionFile (
|
context.makeVisionFile (
|
||||||
Paths.get("customFile.html"),
|
Paths.get("nameFile.html"),
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
resourceLocation = ResourceLocation.EMBED
|
resourceLocation = ResourceLocation.EMBED
|
||||||
){
|
){
|
||||||
div {
|
div {
|
||||||
|
//first vision
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
vision {
|
vision {
|
||||||
solid {
|
solid {
|
||||||
|
//solids which you want to visualize
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
}
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
}
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
//second vision
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
vision {
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
solid {
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
//solids which you want to visualize
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -32,13 +40,13 @@ fun main(){
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
**We will analyze which basic properties solids have using `box` solid.**
|
**We will analyze which basic properties solids have using `box` solid.**
|
||||||
|
|
||||||
*Basic properties:*
|
*Basic properties:*
|
||||||
1. `opacity` - It is set in `float`. It takes on values from 0 to 1, which represent percents of solid opacity. It's initial value is 1.
|
1. `opacity` — It is set in `float`. It takes on values from 0 to 1, which represent percents of solid opacity. It's initial value is 1.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
2. `color` - It can be specified as `Int`, `String`, or as three `Ubytes`, which represent color in `rgb`. Elementally, the solid will have `green` color.
|
2. `color` — It can be specified as `Int`, `String`, or as three `Ubytes`, which represent color in `rgb`. Elementally, the solid will have `green` color.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
3. `rotation` - it's the point, around which the solid will be rotated. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
|
3. `rotation` — it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` — pivot around `y axis`, changing `z` — pivot around `z axis`.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
4. position, which is given by values `x`, `y`, `z`. Initial values are `x = 0`, `y = 0`, `z = 0`. The coordinate system is Cartesian. It's elemental position is this - vertical `y` axis and horizontal `Oxz` plane.
|
4. position, which is given by values `x`, `y`, `z`. Initial values are `x = 0`, `y = 0`, `z = 0`. The coordinate system is Cartesian. It's elemental position is this — vertical `y` axis and horizontal `Oxz` plane.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Let's see how properties are set in solids.
|
Let's see how properties are set in solids.
|
||||||
The `small box` will have elemental values of properties. If you will not set properties, it will have the same `position`, `color`, `rotation`, and `opacity` values.
|
The `small box` will have elemental values of properties. If you don't set properties, it will have the same `position`, `color`, `rotation`, and `opacity` values.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
***You can see that `box` take four values. Later, we will discuss what they do in more detail. Now, it does not really matter.***
|
***You can see that `box` take four values. Later, we will discuss what they do in more detail. Now, it does not really matter.***
|
||||||
```kotlin
|
```kotlin
|
||||||
@ -106,21 +114,49 @@ fun main(){
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
***There is plenty of other properties, especially of those, which you can create by yourself. Here we mention just small part.***
|
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
## Basic Solids
|
## Basic Solids
|
||||||
Now, let's see which solids can be visualized:
|
Now, let's see which solids can be visualized:
|
||||||
### 1) PolyLine
|
### 1) PolyLine
|
||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
It's scarcely a solid, but it can be visualized, so we mention it.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
`polyline` build lines, obviously. Let's take a look at it's work.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
`polyline` requires two values — `points`, and `name`:
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
* `points` is a `vararg` with `Point3D` type. It takes pairs of points, which you want to connect.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
It's type is `String`. **This value can be required by any solid;
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
you can set it, you can not to set it, but without you won't be able to control solid, since it won't be inherited.**
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
This is an example of polyline with other solid `box`:
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
```kotlin
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
box(100, 100, 100, name = "box"){
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
x = -10
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
y = -10
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
z = -10
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
opacity = 0.4
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
}
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
polyline(Point3D(30, 20, 10), Point3D(30, -100, 30), Point3D(30, -100, 30), Point3D(50, -100, 30), name = "polyline"){
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
color("red")
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
}
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
```
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
### 2) Box
|
### 2) Box
|
||||||
|
|
||||||
First thing which has to be mentioned is that `box` takes four values: `box(x, y, z, name)`
|
First thing which has to be mentioned is that `box` takes four values: `box(x, y, z, name)`
|
||||||
* `x` - x-axis length of the `box`
|
* `x` — x-axis length of the `box`
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
* `y` - y-axis length of the `box`
|
* `y` — y-axis length of the `box`
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
* `z` - z-axis length of the `box`
|
* `z` — z-axis length of the `box`
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
These values have `Float` type. *`x`, `y`, and `z` are necessary values, which cannot be ignored. You have to set them.*
|
These values have `Float` type.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
* `name` - `box`'es identifier with `String` type. *It's an optional value, but without it you won't be able to control solid.*
|
*`x`, `y`, and `z` are necessary values, which cannot be ignored. You have to set them.*
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
* `name` — `box`'es identifier. You've already met it.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Let's create just usual `box` with equal ribs.
|
Let's create just usual `box` with equal ribs.
|
||||||
|
|
||||||
@ -137,11 +173,11 @@ Now, let's make `box` with bigger `y` value.
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
color("black")
|
color("black")
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
As you can see, only rib of `y-axis` differs from other ribs.
|
As you can see, only the rib of `y-axis` differs from other ribs.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
For final trial, let's create `box` with bigger `x` value.
|
For a final trial, let's create a `box` with a bigger `x` value.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
```kotlin
|
```kotlin
|
||||||
box(65, 40, 40, name = "wide box") {
|
box(65, 40, 40, name = "wide box") {
|
||||||
@ -151,16 +187,16 @@ For final trial, let's create `box` with bigger `x` value.
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
color("black")
|
color("black")
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
Predictably, only `x-axis` rib bigger than other ribs.
|
Predictably, only the `x-axis` rib is bigger than other ribs.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
### 3) Sphere
|
### 3) Sphere
|
||||||
|
|
||||||
It takes in two values: `radius`, and `name`.
|
It takes in two values: `radius`, and `name`.
|
||||||
Actually, `name` is general value for all solids, so do not wonder, since all solids need their own identifier.
|
We bring you to mind that `name` is a general value for all solids, so do not wonder, since all solids need their own identifier.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
As for `radius`, it has `Float` type, and, as you can guess, it sets radius of the sphere, which will be created.
|
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
```kotlin
|
```kotlin
|
||||||
sphere(50, name = "sphere") {
|
sphere(50, name = "sphere") {
|
||||||
x = 0
|
x = 0
|
||||||
@ -186,7 +222,7 @@ It is solid which has six edges. It is set by eight values: `node1`,..., `node8`
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
|
|
||||||
|
|
||||||
As hexagon takes in specific points, we understand that this solid cannot be moved, it fixed in space, and it can't make pivots.
|
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Let's make classic parallelepiped.
|
Let's make classic parallelepiped.
|
||||||
```kotlin
|
```kotlin
|
||||||
@ -217,7 +253,8 @@ Now, let's make a custom hexagon.
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
Point3D(12, 16, 0),
|
Point3D(12, 16, 0),
|
||||||
Point3D(10, 16, -5),
|
Point3D(10, 16, -5),
|
||||||
Point3D(6.5, 12, -3),
|
Point3D(6.5, 12, -3),
|
||||||
name = "custom_hexagon"){
|
name = "custom_hexagon"
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
) {
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
color("brown")
|
color("brown")
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
@ -225,11 +262,11 @@ Now, let's make a custom hexagon.
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
### 3) Cone
|
### 3) Cone
|
||||||
It takes in six values: `bottomRadius`, `height`, `upperRadius`, `startAngle`, `angle`, and `name`.
|
It takes in six values: `bottomRadius`, `height`, `upperRadius`, `startAngle`, `angle`, and `name`.
|
||||||
|
|
||||||
Obviously, `bottomRadius` is responsible for radius of a bottom base, and `height` sets height of a cone along the `z-axis`.
|
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
As it takes such values as `upperRadius`, `startAngle`, `angle`, `cone` can build not only usual cones, but also cone segments. Initially, `upperRadius` will have `0.0` value, `startAngle` - `0f`, `angle` - `PI2`, so if you don't set them, you'll get just a simple cone.
|
As it takes such values as `upperRadius`, `startAngle`, `angle`, `cone` can build not only usual cones, but also cone segments. Initially, `upperRadius` will have `0.0` value, `startAngle` — `0f`, `angle` — `PI2`, so if you don't set them, you'll get just a simple cone.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Setting `upperRadius`, you make a frustum cone, since it sets a radius of the upper base of a cone. Set `startAngle`, and `angle` let to cut off segments by planes perpendicular to the base. `startAngle` - an angle, starting with which segment will be left, `angle` - an angle of cone, which will be set from `startAngle`.
|
Setting `upperRadius`, you make a frustum cone, since it sets a radius of the upper base of a cone. Set `startAngle`, and `angle` let to cut off segments by planes perpendicular to the base. `startAngle` — an angle, starting with which segment will be left, `angle` — an angle of cone, which will be set from `startAngle`.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Let's build a classic cone:
|
Let's build a classic cone:
|
||||||
```kotlin
|
```kotlin
|
||||||
@ -270,7 +307,7 @@ cone(60, 100, 20, PI*3/4, angle = PI/3, name = "cone") {
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
This solid is set by seven values:`bottomOuterRadius`, `bottomInnerRadius`, `height`, `topOuterRadius`, `topInnerRadius`, `startAngle`, and `angle`.
|
This solid is set by seven values:`bottomOuterRadius`, `bottomInnerRadius`, `height`, `topOuterRadius`, `topInnerRadius`, `startAngle`, and `angle`.
|
||||||
|
|
||||||
In addition to `height`, `startAngle`, and `angle`, which work as they work in `cone`, there are some new values.
|
In addition to `height`, `startAngle`, and `angle`, which work as they work in `cone`, there are some new values.
|
||||||
`bottomOuterRadius`, and `bottomInnerRadius` set properties of the bottom circle, `topOuterRadius`, `topInnerRadius` - of the upper circle. They have no initial value, so that means they have to be set.
|
`bottomOuterRadius`, and `bottomInnerRadius` set properties of the bottom circle, `topOuterRadius`, `topInnerRadius` — of the upper circle. They have no initial value, so that means they have to be set.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
Generally, `cone`, and `coneSurface` buildings work in the same way, it's possible to make `coneSurface`'s fragments as in `cone`
|
Generally, `cone`, and `coneSurface` buildings work in the same way, it's possible to make `coneSurface`'s fragments as in `cone`
|
||||||
|
|
||||||
@ -331,3 +368,6 @@ tube(50, 40, 20, 0f, PI, name = "fragmented tube"){
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|
||||||
### 7) Extruded
|
### 7) Extruded
|
||||||
|
|
||||||
|
`extruded` is set by two values: `shape`, and `layer`.
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
|
||||||
|
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
|
|||||||
|
Use Use `—` (—) instead of ` - `.
Use Use `—` (—) instead of ` - `.
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
hexagon(
Point3D(5, 30, 5),
Point3D(24, 30, 8),
Point3D(20, 30, -10),
Point3D(5, 30, -7),
Point3D(8, 16, 0),
Point3D(12, 16, 0),
Point3D(10, 16, -5),
Point3D(6.5, 12, -3),
name = "custom_hexagon"
) {
color("brown")
}
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
It's scarcely a solid, but it can be visualized, so we mention it.
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
* `shape` is a value of `List<Point2D>` type. It's just a list of all points of the solid. *`shape` has to consist of not less than two points!*
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
#### The main goal of this tutorial is to show the main capabilities of the visualization instrument.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
3. `rotation` - it's the point, which sets rotations along axes. Initially, the value is `Point3D(0, 0, 0)`. Changing `x` coordinate of the point, you make pivot around `x axis`. The same for other coordinates: changing `y` - pivot around `y axis`, changing `z` - pivot around `z axis`.
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
***There is plenty of other properties, especially those, which you can create by yourself. Here we mention just a small part.***
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
* `name` is an identifier of *any solid*; but in this case, it is an identifier of `polyline`.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
As you can see, only the rib of `y-axis` differs from other ribs.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
For a final trial, let's create a `box` with a bigger `x` value.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
Predictably, only the `x-axis` rib is bigger than other ribs.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As for `radius`, it has `Float` type, and, as you can guess, it sets the radius of the sphere which will be created.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
As the hexagon takes in specific points, we understand that this solid cannot be moved, it is fixed in space, and it can't make pivots.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
Obviously, `bottomRadius` is responsible for the radius of a bottom base, and `height` sets the height of a cone along the `z-axis`.
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
```suggestion
* `layer` is `MutableList` types variable. (here is a sentence with a description of the work of this function). *The amount of `layer`-s has to be more than one*
```
|
|||||||
@ -248,7 +248,7 @@ private class GdmlTransformerEnv(val settings: GdmlTransformer) {
|
|||||||
name = name
|
name = name
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
is GdmlXtru -> extrude(name) {
|
is GdmlXtru -> extruded(name) {
|
||||||
shape {
|
shape {
|
||||||
solid.vertices.forEach {
|
solid.vertices.forEach {
|
||||||
point(it.x * lScale, it.y * lScale)
|
point(it.x * lScale, it.y * lScale)
|
||||||
@ -284,7 +284,7 @@ private class GdmlTransformerEnv(val settings: GdmlTransformer) {
|
|||||||
name = name,
|
name = name,
|
||||||
)
|
)
|
||||||
is GdmlOrb -> sphere(solid.r * lScale, name = name)
|
is GdmlOrb -> sphere(solid.r * lScale, name = name)
|
||||||
is GdmlPolyhedra -> extrude(name) {
|
is GdmlPolyhedra -> extruded(name) {
|
||||||
//getting the radius of first
|
//getting the radius of first
|
||||||
require(solid.planes.size > 1) { "The polyhedron geometry requires at least two planes" }
|
require(solid.planes.size > 1) { "The polyhedron geometry requires at least two planes" }
|
||||||
val baseRadius = solid.planes.first().rmax * lScale
|
val baseRadius = solid.planes.first().rmax * lScale
|
||||||
|
|||||||
@ -94,7 +94,9 @@ public class Extruded(
|
|||||||
|
|
||||||
public class ExtrudeBuilder(
|
public class ExtrudeBuilder(
|
||||||
public var shape: List<Point2D> = emptyList(),
|
public var shape: List<Point2D> = emptyList(),
|
||||||
public var layers: ArrayList<Layer> = ArrayList(),
|
|
||||||
|
public var layers: MutableList<Layer> = ArrayList(),
|
||||||
|
|
||||||
config: Config = Config()
|
config: Config = Config()
|
||||||
) : SimpleVisionPropertyContainer<Extruded>(config) {
|
) : SimpleVisionPropertyContainer<Extruded>(config) {
|
||||||
public fun shape(block: Shape2DBuilder.() -> Unit) {
|
public fun shape(block: Shape2DBuilder.() -> Unit) {
|
||||||
@ -109,7 +111,7 @@ public class ExtrudeBuilder(
|
|||||||
}
|
}
|
||||||
|
|
||||||
@VisionBuilder
|
@VisionBuilder
|
||||||
public fun VisionContainerBuilder<Solid>.extrude(
|
public fun VisionContainerBuilder<Solid>.extruded(
|
||||||
name: String? = null,
|
name: String? = null,
|
||||||
action: ExtrudeBuilder.() -> Unit = {}
|
action: ExtrudeBuilder.() -> Unit = {}
|
||||||
): Extruded = ExtrudeBuilder().apply(action).build().also { set(name, it) }
|
): Extruded = ExtrudeBuilder().apply(action).build().also { set(name, it) }
|
||||||
Loading…
Reference in New Issue
Block a user
Use
—(—) instead of-.Use
—(—) instead of-.