{"id":9580,"date":"2020-06-12T18:37:46","date_gmt":"2020-06-12T16:37:46","guid":{"rendered":"https:\/\/www.espai.es\/blog\/?p=9580"},"modified":"2021-09-13T20:32:39","modified_gmt":"2021-09-13T18:32:39","slug":"generacion-procedural-de-modelos-3d-en-unity","status":"publish","type":"post","link":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/","title":{"rendered":"Generaci\u00f3n procedural de modelos 3D en Unity"},"content":{"rendered":"<p>Cuando queremos usar un modelo 3D para nuestro <a href=\"https:\/\/www.espai.es\/index.php\/curso-desarrollo-videojuegos-en-barcelona\" target=\"_blank\" rel=\"noopener\">videojuego hecho en Unity<\/a>, podemos crearlo usando una herramienta externa como <a href=\"https:\/\/www.espai.es\/index.php\/curso-diseno-grafico-y-3ds-max-en-barcelona\" target=\"_blank\" rel=\"noopener\">Autodesk 3DS Max<\/a>, o bien usar los sencillos modelos 3D que Unity puede generar (cubo, esfera, plano, etc.). Estos modelos que Unity puede generar, se crean mediante <strong>un algoritmo que se encarga de calcular todos los v\u00e9rtices y las caras de dicho modelo 3D<\/strong>. Del mismo modo que Unity puede crear mediante programaci\u00f3n estos modelos 3D, podemos escribir un script con C# para generar nuestros propios modelos 3D. Esto es lo que se conoce como <strong>generaci\u00f3n procedural (o param\u00e9trica) de modelos<\/strong>.<\/p>\n<p>Obviamente, cuanto m\u00e1s complejo sea el modelo 3D, m\u00e1s complejo ser\u00e1 el algoritmo para generarlo. Por lo que es importante valorar hasta que punto nos puede resultar \u00fatil, o no, generar modelos de esta forma.<\/p>\n<h2>Ventajas de la generaci\u00f3n param\u00e9trica de \u00abassets\u00bb<\/h2>\n<p>Las principales ventajas que nos ofrece esta forma de trabajar son:<\/p>\n<ul>\n<li>Podemos generar modelos sin necesidad de tener que abrir una aplicaci\u00f3n externa a Unity, crear un modelo, exportarlo y luego volverlo a importar en Unity, por lo que el flujo de trabajo es m\u00e1s \u00f3ptimo.<\/li>\n<li>Al generarse estos modelos con un algoritmo matem\u00e1tico, <strong>podemos generar tantas variantes como permita el algoritmo<\/strong> simplemente variando los par\u00e1metros de dicho algoritmo (de ah\u00ed el nombre de generaci\u00f3n param\u00e9trica), e incluso generar modelos 3D bajo demanda seg\u00fan la interacci\u00f3n del jugador. Esto nos va a permitir <strong>generar infinitas variantes del mismo tipo de modelo 3D<\/strong> sin necesidad de modelar, con tan solo aplicar cambios a los par\u00e1metros que usa el algoritmo de generaci\u00f3n.<\/li>\n<li>Si al algoritmo de generaci\u00f3n le a\u00f1adimos cierta aleatoriedad, podemos hablar de <strong>generaci\u00f3n procedural de modelos 3D<\/strong>. Por lo que incluso podemos hacer que los modelos generados sean hasta cierto punto aleatorios (dentro de lo que permita nuestro algoritmo de generaci\u00f3n). Ejemplos t\u00edpicos de generaci\u00f3n procedural podr\u00edan ser la generaci\u00f3n de terrenos o la generaci\u00f3n de arboles.<\/li>\n<\/ul>\n<p>Para lograr nuestro objetivo, necesitaremos tener los conocimientos matem\u00e1ticos suficientes para poder escribir <strong>un algoritmo que nos calcule la posici\u00f3n de cada v\u00e9rtice y nos calcule los indices de cada cara de nuestro modelo 3D<\/strong>. Si el modelo es sencillo, por lo general, el apartado matem\u00e1tico ser\u00e1 sencillo, pero si el modelo es complejo la parte matem\u00e1tica puede serlo tambi\u00e9n. Obviamente, junto al tiempo que implica programar el script de generaci\u00f3n, estas son las principales desventajas de esta forma de trabajar.<\/p>\n<h2>Generar un terreno proceduralmente en Unity<\/h2>\n<p>Aunque Unity ya incluye herramientas para generar terrenos, vamos a crear nuestro propio generador (mucho m\u00e1s sencillo, claro). Y lo vamos a hacer, porque es una forma bastante sencilla de comprender como funciona esta forma de trabajar y las posibilidades que nos ofrece.<\/p>\n<p><strong>Primero vamos a crear un Game Object vac\u00edo<\/strong> (bot\u00f3n derecho sobre la jerarqu\u00eda de objetos de la escena y seleccionamos \u00abCreate Empty\u00bb). Despu\u00e9s, a este Game Object, le vamos a a\u00f1adir los siguientes 3 componentes:<\/p>\n<ul>\n<li><strong>Mesh Filter<\/strong> &#8211; este componente <strong>almacenar\u00e1 la informaci\u00f3n del modelo 3D<\/strong>.<\/li>\n<li><strong>Mesh Renderer<\/strong> &#8211; este componente<strong> lo pintar\u00e1 en pantalla<\/strong> usando el material que le indicamos. Por lo que debemos de indicar un material en \u00abElemento 0\u00bb dentro de \u00abMaterials\u00bb o de lo contrario se utilizar\u00e1 el material por defecto.<\/li>\n<li><strong>New Script<\/strong> &#8211; le ponemos de nombre \u00abGeneradorDeTerreno.cs\u00bb, lo abrimos para editar y le ponemos el siguiente contenido a dicho script:<\/li>\n<\/ul>\n<pre>using System.Collections;\r\nusing System.Collections.Generic;\r\nusing UnityEngine;\r\n\r\n[RequireComponent(typeof(MeshFilter))]\r\npublic class GeneradorDeTerreno : MonoBehaviour\r\n{\r\n  public int m_Seed = 0; \/\/ semilla\r\n  public int m_Rows = 25; \/\/ n\u00famero de filas\r\n  public int m_Columns = 25; \/\/ n\u00famero de columnas\r\n  public float m_CellSize = 1.0f; \/\/ ancho de la celda\r\n  public float m_Height = 3.0f; \/\/ altura\r\n  public float m_NoiseScale = 0.25f; \/\/ escala del ruido\r\n  public float m_TexCoordScale = 1.0f; \/\/ escala del mapa UV\r\n\r\n  Vector3[] vertex; \/\/ para los v\u00e9rtices\r\n  Vector2[] texcoor; \/\/ para las coordenadas de textura\r\n  int[] index; \/\/ para las tri\u00e1ngulos\r\n  Mesh mesh; \/\/ nuestro modelo 3D\r\n\r\n  void RegenerateMesh()\r\n  {\r\n    Random.InitState(m_Seed);\r\n    float rdm = Random.Range(0f, 10000f);\r\n    float uvscale = 1.0f \/ m_TexCoordScale;\r\n\r\n    \/\/ generaci\u00f3n de los v\u00e9rtices (posici\u00f3n y coordenadas de textura)\r\n    int vtxCount = (m_Rows + 1) * (m_Columns + 1);\r\n    vertex = new Vector3[vtxCount];\r\n    texcoor = new Vector2[vtxCount];\r\n    int vtx = 0;\r\n    float x = 0f; \/\/ posici\u00f3n X\r\n    float y = 0f; \/\/ posici\u00f3n Y\r\n    float z = 0f; \/\/ posici\u00f3n Z\r\n    for (int i=0;i&lt;=m_Rows;i++)\r\n    {\r\n      x = 0f;\r\n      for (int j=0;j&lt;=m_Columns;j++)\r\n      {\r\n        \/\/ posici\u00f3n\r\n        y = m_Height * Mathf.PerlinNoise(\r\n          (x * m_NoiseScale) + rdm,\r\n          (z * m_NoiseScale) + rdm);\r\n        vertex[vtx] = new Vector3(x, y, z);\r\n\r\n        \/\/ coordenada de textura\r\n        texcoor[vtx] = new Vector2(x * uvscale, z * uvscale);\r\n\r\n        \/\/ siguiente v\u00e9rtice\r\n        vtx++;\r\n        x = x + m_CellSize;\r\n      }\r\n      z = z + m_CellSize;\r\n    }\r\n\r\n    \/\/ generaci\u00f3n de los indices de los tri\u00e1ngulos\r\n    int indexCount = m_Rows * m_Columns * 2 * 3;\r\n    index = new int[indexCount];\r\n    int idx = 0;\r\n    for (int i=0;i&lt;m_Rows;i++)\r\n    {\r\n      int offset = i * (m_Columns + 1);\r\n      for (int j=0;j&lt;m_Columns;j++)\r\n      {\r\n        \/\/ obtenemos los indices de los 4 v\u00e9rtices que forman la celda\r\n        int a = offset + j;\r\n        int b = a + m_Columns + 1;\r\n        int c = b + 1;\r\n        int d = a + 1;\r\n\r\n        \/\/ primer tri\u00e1ngulo\r\n        index[idx ] = a;\r\n        index[idx + 1] = b;\r\n        index[idx + 2] = d;\r\n\r\n        \/\/ segundo tri\u00e1ngulo\r\n        index[idx + 3] = d;\r\n        index[idx + 4] = b;\r\n        index[idx + 5] = c;\r\n\r\n        \/\/ siguiente celda\r\n        idx = idx + 6;\r\n      }\r\n    }\r\n\r\n    \/\/ asignamos informaci\u00f3n al modelo 3D\r\n    mesh.Clear();\r\n    mesh.vertices = vertex;\r\n    mesh.uv = texcoor;\r\n    mesh.triangles = index;\r\n    mesh.RecalculateNormals();\r\n  }\r\n\r\n  void Start()\r\n  {\r\n    mesh = new Mesh();\r\n    MeshFilter mf = transform.GetComponent&lt;MeshFilter&gt;();\r\n    mf.mesh = mesh;\r\n    RegenerateMesh();\r\n  }\r\n\r\n}\r\n<\/pre>\n<p><strong>IMPORTANTE: Para poder ver el terreno generado deberemos de pulsar el bot\u00f3n de Play<\/strong>.<\/p>\n<p>Si hemos seguido los pasos correctamente, podremos observar que el terreno ha sido generado con \u00e9xito.<\/p>\n<div id=\"attachment_10112\" style=\"width: 1314px\" class=\"wp-caption aligncenter\"><a href=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno.jpg\"><img loading=\"lazy\" decoding=\"async\" aria-describedby=\"caption-attachment-10112\" class=\"wp-image-10112 size-full\" src=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno.jpg\" alt=\"Terreno generado proceduralmente en Unity\" width=\"1304\" height=\"768\" srcset=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno.jpg 1304w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno-300x177.jpg 300w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno-768x452.jpg 768w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno-1024x603.jpg 1024w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/terreno-700x412.jpg 700w\" sizes=\"auto, (max-width: 1304px) 100vw, 1304px\" \/><\/a><p id=\"caption-attachment-10112\" class=\"wp-caption-text\">Terreno generado proceduralmente en Unity<\/p><\/div>\n<p><strong>Todos los modelos 3D de Unity est\u00e1n formados por tri\u00e1ngulos<\/strong>. Y cada triangulo viene definido por sus 3 v\u00e9rtices. <strong>Para cada v\u00e9rtice necesitamos b\u00e1sicamente su posici\u00f3n y sus coordenadas de textura<\/strong> (mapeado UV).<\/p>\n<p>Algunos tri\u00e1ngulos comparten v\u00e9rtices con otros tri\u00e1ngulos del modelo 3D. Es por ello que <strong>para indicar cada triangulo se debe de indicar el \u00edndice de cada uno de sus 3 v\u00e9rtices<\/strong>.<\/p>\n<p>En el caso del terreno que estamos generando, la malla del modelo 3D es b\u00e1sicamente una rejilla, tal y como se puede apreciar en la siguiente imagen:<\/p>\n<div id=\"attachment_10110\" style=\"width: 701px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" aria-describedby=\"caption-attachment-10110\" class=\"size-full wp-image-10110\" src=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/rejilla.png\" alt=\"Rejilla terreno procedural en Unity\" width=\"691\" height=\"359\" srcset=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/rejilla.png 691w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/rejilla-300x156.png 300w\" sizes=\"auto, (max-width: 691px) 100vw, 691px\" \/><p id=\"caption-attachment-10110\" class=\"wp-caption-text\">Vista superior de una rejilla de un terreno creado con generaci\u00f3n procedural en Unity<\/p><\/div>\n<p>Lo \u00fanico que diferencia esa rejilla de un terreno es que en la rejilla todos los v\u00e9rtices tienen la misma altura, y en un terreno la altura de los v\u00e9rtices va variando.<\/p>\n<h2>El m\u00e9todo RegenerateMesh<\/h2>\n<p>Lo primero que hace este m\u00e9todo de este script es inicializar un valor aleatorio (semilla\/<strong>seed<\/strong>) que se usar\u00e1 para que<strong> el azar nos permita generar diferentes terrenos<\/strong>. Hay que tener en cuenta que tal y como est\u00e1 hecho, cada vez que le demos al Play no va a generar un terreno diferente. Para ello, antes debemos de modificar el valor de Seed en el Inspector de Unity. La idea es que<strong> un mismo valor de Seed generar\u00e1 siempre el mismo terreno<\/strong>, pero cambiando ese valor el terreno cambiar\u00e1 considerablemente por uno totalmente diferente. Esto es lo que diferencia un modelo generado param\u00e9tricamente de uno proceduralmente.<\/p>\n<p>Despu\u00e9s, tenemos un doble bucle for que generar\u00e1 <strong>filas de v\u00e9rtices<\/strong>; para cada v\u00e9rtice calcular\u00e1 la posici\u00f3n y las coordenadas de textura. La posici\u00f3n es sencilla, ya que simplemente conforme vamos a\u00f1adiendo v\u00e9rtices nos vamos desplazando hacia la derecha, y cada vez que cambiamos de fila nos desplazamos hacia adelante (hacia arriba si estamos viendo la rejilla desde una vista superior).<\/p>\n<p>Lo m\u00e1s dif\u00edcil de entender de este c\u00f3digo probablemente sea el c\u00e1lculo de la \u00abaltura\u00bb (posici\u00f3n Y) de cada v\u00e9rtice. Para ello se usa el m\u00e9todo <a href=\"https:\/\/docs.unity3d.com\/ScriptReference\/Mathf.PerlinNoise.html\" target=\"_blank\" rel=\"noopener\">Mathf.PerlinNoise()<\/a> de Unity. Este m\u00e9todo nos ira dando diferentes valores para la altura pero no lo har\u00e1 simplemente de forma aleatoria, sino que son valores que siguen un patr\u00f3n de \u00abondas\u00bb llamado <a href=\"https:\/\/es.wikipedia.org\/wiki\/Ruido_Perlin\" target=\"_blank\" rel=\"noopener\">ruido perl\u00edn<\/a> que dan ese ese aspecto de terreno a nuestra rejilla de v\u00e9rtices. Todos los v\u00e9rtices generados se van guardando en un array.<\/p>\n<div id=\"attachment_10124\" style=\"width: 510px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" aria-describedby=\"caption-attachment-10124\" class=\"size-full wp-image-10124\" src=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/PerlinNoise2d.png\" alt=\"Perlin Noise\" width=\"500\" height=\"500\" srcset=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/PerlinNoise2d.png 500w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/PerlinNoise2d-150x150.png 150w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/PerlinNoise2d-300x300.png 300w\" sizes=\"auto, (max-width: 500px) 100vw, 500px\" \/><p id=\"caption-attachment-10124\" class=\"wp-caption-text\">El Perlin Noise es un tipo de ruido usado frecuentemente en la generaci\u00f3n procedural de modelos org\u00e1nicos.<\/p><\/div>\n<p>Se pueden hacer terrenos m\u00e1s convincentes generando una altura para el terreno global mediante un ruido perl\u00edn de baja frecuencia en sus ondulaciones (lo que serian las monta\u00f1as y valles del terreno), mientras que para los detalles locales del terreno se podr\u00eda usar otra altura adicional mediante otro ruido perl\u00edn de mayor frecuencia en sus ondulaciones (lo que ser\u00edan las rocas, agujeros, etc. del terreno). Para ello, para calcular la altura bastar\u00eda con llamar varias veces al m\u00e9todo PerlinNoise() con diferentes par\u00e1metros, pero en nuestro caso vamos a mantener el ejemplo sencillo y solo lo vamos a usar una \u00fanica vez.<\/p>\n<p>A continuaci\u00f3n, tenemos otro doble bucle for para generar los tri\u00e1ngulos. Una vez generados los v\u00e9rtices, <strong>para generar cada triangulo simplemente hemos de indicar la posici\u00f3n de sus 3 v\u00e9rtices en el array de v\u00e9rtices<\/strong>. Sin embargo, hay que tener en cuenta que<strong> los v\u00e9rtices del tri\u00e1ngulo deben de indicarse siguiendo un orden <em>clockwise.<\/em><\/strong> Es decir, hemos de indicar los v\u00e9rtices de forma que sigan el sentido de las agujas del reloj. Adem\u00e1s, hay que tener en cuenta que <strong>para cada celda de la rejilla necesitamos un par de tri\u00e1ngulos que comparten un par de v\u00e9rtices<\/strong>. Por lo que tenemos 4 v\u00e9rtices por celda a los que podemos llamar <strong>a<\/strong>, <strong>b<\/strong>, <strong>c<\/strong> y <strong>d<\/strong>.<\/p>\n<div id=\"attachment_10115\" style=\"width: 322px\" class=\"wp-caption aligncenter\"><img loading=\"lazy\" decoding=\"async\" aria-describedby=\"caption-attachment-10115\" class=\"size-full wp-image-10115\" src=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/orden_vertices.png\" alt=\"Orden de los vertices de un quad en Unity\" width=\"312\" height=\"336\" srcset=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/orden_vertices.png 312w, https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/orden_vertices-279x300.png 279w\" sizes=\"auto, (max-width: 312px) 100vw, 312px\" \/><p id=\"caption-attachment-10115\" class=\"wp-caption-text\">Los 4 v\u00e9rtices y 2 tri\u00e1ngulos de un quad en Unity<\/p><\/div>\n<p>Tal y como se puede observar en la anterior ilustraci\u00f3n, cada celda de nuestro terreno est\u00e1 formada por 2 tri\u00e1ngulos que comparten 2 v\u00e9rtices. Los v\u00e9rtices <strong>a<\/strong> y <strong>d<\/strong> pertenecen a la misma fila de v\u00e9rtices generados en el primer paso, mientras que los v\u00e9rtices <strong>b<\/strong> y <strong>c<\/strong> pertenecen a la siguiente fila de v\u00e9rtices. Una vez averiguados los valores de los indices de dichos v\u00e9rtices, para indicar el triangulo azul debemos de indicar los valores de <strong>a<\/strong>, <strong>b<\/strong> y <strong>d<\/strong>, y hacerlo adem\u00e1s en dicho orden (sentido de las agujas del reloj). Tambi\u00e9n podr\u00edamos indicar los valores de<strong> b<\/strong>, <strong>d<\/strong> y <strong>a<\/strong>, o los valores de <strong>d<\/strong>, <strong>a<\/strong> y <strong>b<\/strong>; lo importante es respetar el sentido de las manecillas del reloj. Lo mismo se aplica para el triangulo rojo, podemos elegir cualquiera de sus 3 vertices para empezar, pero el orden ha de ser el de las manecillas del reloj.<\/p>\n<p>Una vez tenemos listos los arrays con las posiciones de los v\u00e9rtices, las coordenadas UV para el mapeado de textura y los indices de los v\u00e9rtices que forman los tri\u00e1ngulos, tan solo hay que indic\u00e1rselos al objeto <strong>Mesh<\/strong> que tenemos en el <strong>Mesh Filter<\/strong>. Como no hemos calculado <a href=\"https:\/\/es.wikipedia.org\/wiki\/Vector_normal\" target=\"_blank\" rel=\"noopener\">las normales de cada v\u00e9rtice<\/a>, con el m\u00e9todo <strong>RecalculateNormals() <\/strong>Unity las calcular\u00e1 por nosotros. Para ello simplemente calcular\u00e1 la normal de cada triangulo al que pertenece cada v\u00e9rtice, las sumar\u00e1, y el vector resultante lo normalizar\u00e1. En el caso del terreno que estamos generando, estas normales generadas por Unity son adecuadas, pero en otro tipo de modelo 3D, tal vez sea mejor generar las normales \u00aba mano\u00bb. <strong>La normal de un v\u00e9rtice<\/strong> indica hacia donde apunta dicho v\u00e9rtice y es muy importante a nivel de iluminaci\u00f3n.<\/p>\n<p>Y nada m\u00e1s, espero que el c\u00f3digo sea lo bastante claro y os animo a generar otro tipo de modelos 3D seg\u00fan vuestras necesidades mediante generaci\u00f3n procedural.<\/p>\n<p>&nbsp;<\/p>\n<p>&nbsp;<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Cuando queremos usar un modelo 3D para nuestro videojuego hecho en Unity, podemos crearlo usando una herramienta externa como Autodesk 3DS Max, o bien usar los sencillos modelos 3D que Unity puede generar (cubo, esfera, plano, etc.). Estos modelos que Unity puede generar, se crean&#8230;<\/p>\n","protected":false},"author":23,"featured_media":10109,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_ef_editorial_meta_date_first-draft-date":"","_ef_editorial_meta_paragraph_assignment":"","_ef_editorial_meta_checkbox_needs-photo":"","_ef_editorial_meta_number_word-count":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[5],"tags":[736,322],"class_list":["post-9580","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programacion","tag-generacion-procedural","tag-unity"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.1.1 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai<\/title>\n<meta name=\"description\" content=\"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai\" \/>\n<meta property=\"og:description\" content=\"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\" \/>\n<meta property=\"og:site_name\" content=\"Blog Escola Espai\" \/>\n<meta property=\"article:published_time\" content=\"2020-06-12T16:37:46+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-09-13T18:32:39+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1000\" \/>\n\t<meta property=\"og:image:height\" content=\"500\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Abel Camarena\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Escrito por\" \/>\n\t<meta name=\"twitter:data1\" content=\"Abel Camarena\" \/>\n\t<meta name=\"twitter:label2\" content=\"Tiempo de lectura\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\"},\"author\":{\"name\":\"Abel Camarena\",\"@id\":\"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897\"},\"headline\":\"Generaci\u00f3n procedural de modelos 3D en Unity\",\"datePublished\":\"2020-06-12T16:37:46+00:00\",\"dateModified\":\"2021-09-13T18:32:39+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\"},\"wordCount\":1692,\"commentCount\":0,\"image\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg\",\"keywords\":[\"generaci\u00f3n procedural\",\"unity\"],\"articleSection\":[\"Programaci\u00f3n\"],\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\",\"url\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\",\"name\":\"Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai\",\"isPartOf\":{\"@id\":\"https:\/\/www.espai.es\/blog\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg\",\"datePublished\":\"2020-06-12T16:37:46+00:00\",\"dateModified\":\"2021-09-13T18:32:39+00:00\",\"author\":{\"@id\":\"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897\"},\"description\":\"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.\",\"breadcrumb\":{\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#breadcrumb\"},\"inLanguage\":\"es\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage\",\"url\":\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg\",\"contentUrl\":\"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg\",\"width\":1000,\"height\":500,\"caption\":\"Generaci\u00f3n Procedural de Terrenos con Unity\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Portada\",\"item\":\"https:\/\/www.espai.es\/blog\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Generaci\u00f3n procedural de modelos 3D en Unity\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.espai.es\/blog\/#website\",\"url\":\"https:\/\/www.espai.es\/blog\/\",\"name\":\"Blog Escola Espai\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.espai.es\/blog\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"es\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897\",\"name\":\"Abel Camarena\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es\",\"@id\":\"https:\/\/www.espai.es\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/035501b0f14e120b1a49121758e2056b8d589fc43b9d3c3ad3670a197a90dddf?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/035501b0f14e120b1a49121758e2056b8d589fc43b9d3c3ad3670a197a90dddf?s=96&d=mm&r=g\",\"caption\":\"Abel Camarena\"},\"sameAs\":[\"http:\/\/www.espai.es\"],\"url\":\"https:\/\/www.espai.es\/blog\/author\/abel\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai","description":"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/","og_locale":"es_ES","og_type":"article","og_title":"Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai","og_description":"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.","og_url":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/","og_site_name":"Blog Escola Espai","article_published_time":"2020-06-12T16:37:46+00:00","article_modified_time":"2021-09-13T18:32:39+00:00","og_image":[{"width":1000,"height":500,"url":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","type":"image\/jpeg"}],"author":"Abel Camarena","twitter_card":"summary_large_image","twitter_misc":{"Escrito por":"Abel Camarena","Tiempo de lectura":"10 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#article","isPartOf":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/"},"author":{"name":"Abel Camarena","@id":"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897"},"headline":"Generaci\u00f3n procedural de modelos 3D en Unity","datePublished":"2020-06-12T16:37:46+00:00","dateModified":"2021-09-13T18:32:39+00:00","mainEntityOfPage":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/"},"wordCount":1692,"commentCount":0,"image":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage"},"thumbnailUrl":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","keywords":["generaci\u00f3n procedural","unity"],"articleSection":["Programaci\u00f3n"],"inLanguage":"es","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/","url":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/","name":"Generaci\u00f3n procedural de modelos 3D en Unity - Blog Escola Espai","isPartOf":{"@id":"https:\/\/www.espai.es\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage"},"image":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage"},"thumbnailUrl":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","datePublished":"2020-06-12T16:37:46+00:00","dateModified":"2021-09-13T18:32:39+00:00","author":{"@id":"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897"},"description":"En Unity es posible crear modelos 3D usando un algoritmo que podemos escribir mediante un script C#, lo que se conoce como generaci\u00f3n procedural de modelos.","breadcrumb":{"@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#breadcrumb"},"inLanguage":"es","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/"]}]},{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#primaryimage","url":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","contentUrl":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","width":1000,"height":500,"caption":"Generaci\u00f3n Procedural de Terrenos con Unity"},{"@type":"BreadcrumbList","@id":"https:\/\/www.espai.es\/blog\/2020\/06\/generacion-procedural-de-modelos-3d-en-unity\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Portada","item":"https:\/\/www.espai.es\/blog\/"},{"@type":"ListItem","position":2,"name":"Generaci\u00f3n procedural de modelos 3D en Unity"}]},{"@type":"WebSite","@id":"https:\/\/www.espai.es\/blog\/#website","url":"https:\/\/www.espai.es\/blog\/","name":"Blog Escola Espai","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.espai.es\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"es"},{"@type":"Person","@id":"https:\/\/www.espai.es\/blog\/#\/schema\/person\/b2d40404b9d987e3586e186c021ef897","name":"Abel Camarena","image":{"@type":"ImageObject","inLanguage":"es","@id":"https:\/\/www.espai.es\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/035501b0f14e120b1a49121758e2056b8d589fc43b9d3c3ad3670a197a90dddf?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/035501b0f14e120b1a49121758e2056b8d589fc43b9d3c3ad3670a197a90dddf?s=96&d=mm&r=g","caption":"Abel Camarena"},"sameAs":["http:\/\/www.espai.es"],"url":"https:\/\/www.espai.es\/blog\/author\/abel\/"}]}},"jetpack_featured_media_url":"https:\/\/www.espai.es\/blog\/wp-content\/uploads\/2020\/03\/generacion-procedural-unity.jpg","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/posts\/9580","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/users\/23"}],"replies":[{"embeddable":true,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/comments?post=9580"}],"version-history":[{"count":31,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/posts\/9580\/revisions"}],"predecessor-version":[{"id":10119,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/posts\/9580\/revisions\/10119"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/media\/10109"}],"wp:attachment":[{"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/media?parent=9580"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/categories?post=9580"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.espai.es\/blog\/wp-json\/wp\/v2\/tags?post=9580"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}