Todos los parámetros de un Material que usted ve en el inspector cuando ve un material son accesibles vía script, dándole a usted el poder de cambiar o animar cómo un material funciona en tiempo de ejecución.
Esto le permite a usted modificar valores numéricos en el Material, cambiar colores, e intercambiar texturas dinámicamente durante el gameplay. Algunas de las funciones más comúnmente utilizadas para hacer esto son:
Nombre de la función | Utilice |
---|---|
SetColor | Cambia el color del material (Eg. el color tine albedo) |
SetFloat | Configura un valor punto flotante (Ef. el multiplicador normal map) |
SetInt | Establece un valor entero en el material |
SetTexture | Asigna una nueva textura al material |
El conjunto completo de funciones disponibles para manipular materiales vía script se pueden encontrar en la referencia de scripting de la clase Material.
Una importante aclaración es que estas funciones solamente configuran propiedades que están disponibles para el shader actual en el materia. Esto significa que si usted tiene un shader que no utiliza texturas, o si usted no tiene un shader delimitado en absoluto, llamar SetTexture no tendrá efecto. Esto es true incluso si usted después configura un shader que necesita la textura. Por esta razón se recomienda que usted configure el shader que usted quiere antes de configurar cualquier propiedad, sin embargo una vez usted lo ha hecho esto usted puede cambiar de un shader a otro que utilice las mismas texturas o propiedades y los valores serán preservados.
These functions work as you would expect for all simple shaders such as the legacy shaders, and the built-in shaders other than the Standard Shader (for example, the particle, sprite, UI and unlit shaders). For a material using the Standard Shader however, there are some further requirements which you must be aware of before being able to fully modify the Material.
The Standard Shader has some extra requirements if you want to modify Materials at runtime, because - behind the scenes - it is actually many different shaders rolled into one.
These different types of shader are called Shader Variants and can be thought of as all the different possible combinations of the shader’s features, when activated or not activated.
For example, if you choose to assign a Normal Map to your material, you activate that variant of the shader which supports Normal Mapping. If you subsequently also assign a Height Map then you activate the variant of the shader which supports Normal Mapping and Height Mapping.
This is a good system, because it means that if you use the Standard Shader, but do not use a Normal Map in a certain Material, you are not incurring the performance cost of running the Normal Map shader code - because you are running a variant of the shader with that code omitted. It also means that if you never use a certain feature combination (such as HeightMap & Emissive together), that variant is completely omitted from your build - and in practice you will typically only use a very small number of the possible variants of the Standard Shader.
Unity avoids simply including every possible shader variant in your build, because this would be a very large number, some tens of thousands! This high number is a result not only of each possible combination of features available in the material inspector, but also there are variants of each feature combination for differing rendering scenarios such as whether or not HDR is being used, lightmaps, GI, fog, etc. Including all of these would cause slow loading, high memory consumption, and increase your build size and build time.
Instead, Unity tracks which variants you’ve used by examining the material assets used in your project. Whichever variants of the Standard Shader you have included in your project, those are the variants which are included in the build.
This presents two separate problems when accessing materials via script that use the Standard Shader.
If you use scripting to change a Material that would cause it to use a different variant of the Standard Shader, you must enable that variant by using the EnableKeyword function. A different variant would be required if you start using a shader feature that was not initially in use by the material. For example assigning a Normal Map to a Material that did not have one, or setting the Emissive level to a value greater than zero, when it was previously zero.
The specific Keywords required to enable the Standard Shader features are as follows:
Keyword | Feature |
---|---|
_NORMALMAP | Normal Mapping |
_ALPHATEST_ON | “Cut out” Transparency Rendering Mode |
_ALPHABLEND_ON | “Fade” Transparency Rendering Mode |
_ALPHAPREMULTIPLY_ON | “Transparent” Transparency Rendering Mode |
_EMISSION | Emission Colour o Emission Mapping |
_PARALLAXMAP | Height Mapping |
_DETAIL_MULX2 | Secondary “Detail” Maps (Albedo & Normal Map) |
_METALLICGLOSSMAP | Metallic/Smoothness Mapping in Metallic Workflow |
_SPECCGLOSSMAP | Specular/Smoothness Mapping in Specular Workflow |
Using the keywords above is enough to get your scripted Material modifications working while running in the editor.
However, because Unity only checks for Materials used in your project to determine which variants to include in your build, it will not include variants that are only encountered via script at runtime.
This means if you enable the _PARALLAXMAP keyword for a Material in your script, but you do not have a Material used in your project matching that same feature combination, the parallax mapping will not work in your final build - even though it appears to work in the editor. This is because that variant will have been omitted from the build because it seemed to not be required.
To do this, you need to make sure Unity knows that you want to use that shader variant by including at least one Material of that type in your Assets. The material must be used in a scene or alternatively be placed in your Resources Folder - otherwise Unity will still omit it from your build, because it appeared unused.
By completing both of the above steps, you have the full ability to modify your Materials using the Standard Shader at runtime.
If you are interested in learning more about the details of shader variants, and how to write your own, read about Making multiple shader program variants here.