Cómo utilizar el modelado de contornos en cityengine

Construya un edificio como se muestra a continuación. El edificio tiene una planta baja y otros pisos. Hay una puerta de entrada en el frente del primer piso y otras ventanas usan un modelo OBJ prefabricado.

Comencemos a crear reglas para modelar:

Para comprender mejor las reglas, cree una nueva regla usted mismo y escriba las reglas de acuerdo con las declaraciones del tutorial.

1. Defina las propiedades del edificio al principio del archivo de reglas (también se puede colocar en otras ubicaciones del archivo de reglas). En el archivo CGA, estos atributos tendrán efecto en todo el archivo de reglas. Estas propiedades se mostrarán en el Inspector de propiedades (Inspector) y se pueden modificar a través del Inspector de propiedades.

attr groundfloor_height = 4? //Altura del primer piso

attr floor_height? = 3.5 //Altura de otros pisos

attrtile_width = 3 / /El ancho del piso dividido en bloques

attr height? = 11? //Altura del piso

attr wallColor? = "#fefefe" //Color de la pared

2. La ventana creada en el tutorial utiliza un modelo de ventana window.obj ya creado. Este archivo se almacena en la carpeta de activos y debe definirse antes de su uso.

window_asset = "facades/window.obj" //Especifique el archivo obj

3. La primera regla se define a continuación como Lote. En el inspector de atributos, la regla se especifica como Lote. Comienza las reglas. Una gran cantidad de modelos se crean mediante operaciones de estiramiento:

//Estira la forma usando la altura definida en altura y nómbrala Edificio

Lote -->

extruir (altura) Edificio

Como se muestra a continuación después de estirar:

4. El edificio se puede descomponer en múltiples caras aplicando comp() para generar una cara frontal (FrontFacade), múltiple. lados (Fachada lateral) y una superficie superior (Techo)

Edificio-->

comp(f){ frente: Fachada frontal | lado: Fachada lateral superior: Techo}

5. Una vez completada la descomposición, comience a modelar la apariencia de estas superficies. El proceso típico de modelado exterior es el siguiente:

(1) Descomponer la superficie en pisos (Floors)

(2) Descomponer los pisos en bloques (Baldosas), cada bloque generalmente compuesto por paredes y composición de ventanas. El proceso de implementación de dicho proceso de subdivisión en la sintaxis de elementos CGA es el siguiente:

//La siguiente regla de FrontFacade divide la superficie frontal en dos partes a lo largo de la dirección del eje y. La primera parte es la planta baja. con una altura de planta baja, el resto se divide repetidamente según la altura del piso (marcado con el símbolo *) y se divide en varios pisos.

FrenteFachada -->

split(y){ groundfloor_height : Planta baja | { ~floor_height: Piso }* }

El frente se divide como se muestra a continuación:

p>

6. Subdividir el lado:

SideFacade -->

split(y){ groundfloor_height: Floor { ~floor_height: Floor | }* }

La regla SideFacade divide el lado en dos partes a lo largo de la dirección del eje y. Ambas partes usan el mismo objeto Piso, por lo que las dos partes del lado deben verse iguales. Sólo la altura es diferente. La razón principal de la diferencia de altura es mantenerla consistente con la altura del piso directamente en frente.

Después de la segmentación lateral, como se muestra a continuación, los tres lados son consistentes:

7. Continúe refinando el objeto Piso:

// Primero, dé a cada Draw. paredes con un ancho de 1 (Pared) en ambos extremos del piso en la dirección del eje x, y las partes restantes se dividen repetidamente (Azulejos) con Tile_width como ancho.

Suelo -->> /p>

split(x){ 1: Pared

?| { ~tile_width: Mosaico }*

1: Pared }

Como se muestra a continuación:

8. Finalmente, refine la planta baja delantera:

// De manera similar, dibuje paredes (Muro) con un ancho de 1 en ambos extremos en la dirección del eje x. , Según Tile_width Divídalo en varios Tiles y divida un Tile de entrada según Tile_width.

Planta baja -->split(x){ 1: Pared

|{ ~tile_width: Azulejo }*

| ~tile_width: EntradaTile

| 1: Muro }

El resultado es como se muestra a continuación:

9. Defina Azulejo a continuación:

//Primero defina Azulejo en la x. -eje Divida una parte con un ancho de 2 en el medio de la dirección (para esta parte, primero divida una pared y una ventana con alturas de 1 y 1,5 respectivamente de acuerdo con la dirección del eje y, y la altura restante también se designa como pared), y luego divídalo en dos lados con un ancho de aproximadamente 1's wall

Tile -->

split(x){ ~1 : Wall

| ?2 : split(y){ 1: Muro | 1.5: Ventana ~1: Muro }

| /p>

10. Defina Mosaico de entrada:

Mosaico de entrada -->

dividir(x){ ~1: SolidWall

| (y){ 2.5: Puerta | ~2: SolidWall }

| ~1 : SolidWall }

Primero divida la entrada en una parte con un ancho de 2 en el eje x. dirección (esta parte se divide primero en una puerta con una altura de 2,5 en la dirección del eje y, y la parte restante tiene aproximadamente una altura de 2 Definida como SolidWall), y luego hay Solidwalls de aproximadamente 1 metro en ambos lados .

11. Finalmente, escriba reglas específicas para la Ventana, Puerta, Muro y SolidWall previamente definidos.

Ventana -->

s('1,'1,0.4)

t(0,0,-0.25)

i(window_asset)

Puerta -->

s('1,'1,0.1)

t(0,0,-0.5)

i("builtin:cube")

Pared -->

color(wallColor)

SolidWall -->

color(wallColor)

s('1,'1,0.4)

t(0,0,-0.4)

i( "builtin:cube:notex")

Aquí hay una explicación de los comandos que aparecen arriba:

① s('1,'1,0.4):

Comando: s(float xSize, float ySize, float zSize)

La función establece el tamaño de la forma.

eg1: ?s(5,5,5)? significa establecer los valores en tres direcciones al valor absoluto 5

eg2:? ,' 1.5)? es equivalente a ? s(0.5*scope.sx,scope.sy,1.5*scope.sz). Si agrega el símbolo ', el valor entre paréntesis está entre 0 y 1. valor de xyz al original Cuántas veces.

②t(0,0,-0.25)

Traducción: t(tx, ty, tz)

③i(window_asset) o i("integrado: cube:notex")

Reemplazo de objetos: i(geometryPath)

CityEngine tiene materiales integrados que se pueden usar directamente, divididos en Activos de Geometría y Texturas.

Activos de geometría:

builtin:cube: cubo unitario con nodos, sistema de coordenadas de textura con capa de textura

builtin:cube:notex: cubo unitario, sin textura sistema de coordenadas

Texturas:

integrado: predeterminado: representa una textura cuadrada en blanco y negro de 16 × 16.

integrado:uvtest.png: uso de textura de prueba estándar CE

Efecto final: