Unity CG编程入门：实时3D图形与光照教程

5星 · 超过95%的资源需积分: 9 66 浏览量更新于2024-07-24 1 收藏 15.9MB PDF 举报

《Cg Programming in Unity：实时3D图形入门指南》是一本电子书，主要探讨如何在Unity这个流行的跨平台游戏开发引擎中利用Cg语言进行图形编程。Cg（Compute Graphics）是一种用于实现高效、高性能计算的技术，它结合了高级语言（如C++）的易用性和低级硬件指令集的优势，特别适用于创建复杂的实时图形效果。本书共包含六个章节，从基础知识到高级技术，逐步深入： 1. **Introduction**：首先，读者会被引导进入Cg编程的世界，了解其在Unity中的应用基础和重要性。章节中会介绍一个简单的着色器示例——Minimal Shader，帮助读者理解基本的着色器结构和功能。 2. **Basics**：这部分深入讲解了RGBCube的实现，这是一种三维立方体，用于展示基本颜色和纹理的处理。接下来是着色器调试，学会如何识别和解决常见问题，确保代码的正确执行。 3. **Transparent Surfaces**：透明度是3D图形中的关键特性，作者详细介绍了不同类型的透明度处理方法，包括Cutaways（剪切面）、Transparency（直接透明度）、Order-Independent Transparency（OIT，顺序无关透明性）以及Silhouette Enhancement（轮廓增强），这些都是实现真实光照效果不可或缺的部分。 4. **Basic Lighting**：章节中探讨了基础的光照模型，包括 diffuse reflection（漫反射）、specular highlights（镜面反射）、two-sided surfaces（双面表面）等，并展示了如何通过这些技术创建平滑和真实的光照效果。此外，书中还讨论了多光源照明场景的设计。 5. **Basic Texturing**：纹理在游戏开发中起着至关重要的作用。作者通过textured spheres、lighting textured surfaces、glossy textures、transparent textures和layers of textures等内容，展示了如何在Unity中使用和组合不同的纹理效果。 6. **Textures in 3D**：这部分扩展了纹理的应用，包括光照处理（bumpy surfaces、projection of bumpy surfaces）、环境贴图（cookies、light attenuation）、投影（projectors）以及更复杂的环境映射，如reflecting surfaces、curved glass、skyboxes以及处理多个光源的情况。这本书不仅适合想要学习Cg编程的Unity开发者，也对希望深入了解3D图形渲染技术的读者非常有用。通过阅读这本书，读者能够掌握在Unity中创建逼真、交互式3D场景的关键技能。

1.3•• Debugging of Shaders

float4 vertex : POSITION;

float4 tangent : TANGENT;

float3 normal : NORMAL;

float4 texcoord : TEXCOORD0;

};

struct appdata_full {

float4 vertex : POSITION;

float4 tangent : TANGENT;

float3 normal : NORMAL;

float4 texcoord : TEXCOORD0;

float4 texcoord1 : TEXCOORD1;

fixed4 color : COLOR;

// and additional texture coordinates only on XBOX360)

};

The file UnityCG.cginc is included with the line #include "UnityCG.cginc". Thus, the shader above

could be rewritten this way:

Shader "Cg shader with all built-in vertex input parameters" {

SubShader {

Pass {

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#include "UnityCG.cginc"

struct vertexOutput {

float4 pos : SV_POSITION;

float4 col : TEXCOORD0;

};

vertexOutput vert(appdata_full input)

{

vertexOutput output;

output.pos = mul(UNITY_MATRIX_MVP, input.vertex);

output.col = input.texcoord;

return output;

}

float4 frag(vertexOutput input) : COLOR

{

return input.col;

}

ENDCG

1.3•• Debugging of Shaders

}

How to Interpret False-Color Images

When trying to understand the information in a false-color image, it is important to focus on one color component

only. For example, if the input vertex parameter texcoord with semantic TEXCOORD0 for a sphere is written to

the fragment color then the red component of the fragment visualizes the x coordinate of texcoord, i.e. it doesn't

matter whether the output color is maximum pure red or maximum yellow or maximum magenta, in all cases the red

component is 1. On the other hand, it also doesn't matter for the red component whether the color is blue or green or

cyan of any intensity because the red component is 0 in all cases. If you have never learned to focus solely on one

color component, this is probably quite challenging; therefore, you might consider to look only at one color

component at a time. For example by using this line to set the output parameter in the vertex shader:

output.col = float4(input.texcoord.x, 0.0, 0.0, 1.0);

This sets the red component of the output parameter to the x component of texcoord but sets the green and blue

components to 0 (and the alpha or opacity component to 1 but that doesn't matter in this shader).

If you focus on the red component or visualize only the red component you should see that it increases from 0 to 1 as

you go around the sphere and after 360‚ drops to 0 again. It actually behaves similar to a longitude coordinate on the

surface of a planet. (In terms of spherical coordinates, it corresponds to the azimuth.)

If the x component of texcoord corresponds to the longitude, one would expect that the y component would

correspond to the latitude (or the inclination in spherical coordinates). However, note that texture coordinates are

always between 0 and 1; therefore, the value is 0 at the bottom (south pole) and 1 at the top (north pole). You can

visualize the y component as green on its own with:

output.col = float4(0.0, input.texcoord.y, 0.0, 1.0);

Texture coordinates are particularly nice to visualize because they are between 0 and 1 just like color components

are. Almost as nice are coordinates of normalized vectors (i.e., vectors of length 1; for example, the normal input

parameter is usually normalized) because they are always between -1 and +1. To map this range to the range from 0

to 1, you add 1 to each component and divide all components by 2, e.g.:

output.col = float4(

(input.normal + float3(1.0, 1.0, 1.0)) / 2.0, 1.0);

Note that normal is a three-dimensional vector. Black corresponds then to the coordinate -1 and full intensity of

one component to the coordinate +1.

If the value that you want to visualize is in another range than 0 to 1 or -1 to +1, you have to map it to the range from

0 to 1, which is the range of color components. If you don't know which values to expect, you just have to

experiment. What helps here is that if you specify color components outside of the range 0 to 1, they are

automatically clamped to this range. I.e., values less than 0 are set to 0 and values greater than 1 are set to 1. Thus,

when the color component is 0 or 1 you know at least that the value is less or greater than what you assumed and

then you can adapt the mapping iteratively until the color component is between 0 and 1.

1.3•• Debugging of Shaders

Debugging Practice

In order to practice the debugging of shaders, this section includes some lines that produce black colors when the

assignment to col in the vertex shader is replaced by each of them. Your task is to figure out for each line, why the

result is black. To this end, you should try to visualize any value that you are not absolutely sure about and map the

values less than 0 or greater than 1 to other ranges such that the values are visible and you have at least an idea in

which range they are. Note that most of the functions and operators are documented in Appendix A.3, “Vector and

Matrix Operations”.

output.col = input.texcoord - float4(1.5, 2.3, 1.1, 0.0);

output.col = float4(input.texcoord.z);

output.col = input.texcoord / tan(0.0);

The following lines require some knowledge about the dot and cross product:

output.col = dot(input.normal, float3(input.tangent)) *

input.texcoord;

output.col = dot(cross(input.normal, float3(input.tangent)),

input.normal) * input.texcoord;

output.col = float4(cross(input.normal, input.normal), 1.0);

output.col = float4(cross(input.normal,

float3(input.vertex)), 1.0);

// only for a sphere!

Do the functions radians() and noise() always return black? What's that good for?

output.col = radians(input.texcoord);

output.col = noise(input.texcoord);

Summary

Congratulations, you have reached the end of this tutorial! We have seen:

€€ The list of built-in vertex input paramters in Unity.

€€ How to visualize these parameters (or any other value) by setting components of the fragment output color.

Further Reading

If you still want to know more

€ about the data flow in vertex and fragment shaders, you should read the description in Appendix A.1,

“Programmable Graphics Pipeline”.

€ about operations and functions for vectors, you should read Appendix A.3, “Vector and Matrix Operations”.

1.4•• Shading in World Space

1.4€€ Shading in World Space

Some chameleons are able to change their color

according to the world around them.

This tutorial introduces uniform parameters. It is based on

Section 1.1, “Minimal Shader”, Section 1.2, “RGB Cube”, and

Section 1.3, “Debugging of Shaders”.

In this tutorial we will look at a shader that changes the fragment

color depending on its position in the world. The concept is not too

complicated; however, there are extremely important applications,

e.g. shading with lights and environment maps. We will also have

a look at shaders in the real world; i.e., what is necessary to enable

non-programmers to use your shaders?

Transforming from Object to World Space

As mentioned in Section 1.3, “Debugging of Shaders”, the vertex

input parameter with semantic POSITION specifies object

coordinates, i.e. coordinates in the local object (or model) space of

a mesh. The object space (or object coordinate system) is specific

to each game object; however, all game objects are transformed into one common coordinate system — the world

space.

If a game object is put directly into the world space, the object-to-world transformation is specified by the Transform

component of the game object. To see it, select the object in the Scene View or the Hierarchy View and then find

the Transform component in the Inspector View. There are parameters for “Position”, “Rotation” and “Scale” in the

Transform component, which specify how vertices are transformed from object coordinates to world coordinates. (If

a game object is part of a group of objects, which is shown in the Hierarchy View by means of indentation, then the

Transform component only specifies the transformation from object coordinates of a game object to the object

coordinates of the parent. In this case, the actual object-to-world transformation is given by the combination of the

transformation of a object with the transformations of its parent, grandparent, etc.) The transformations of vertices by

translations, rotations and scalings, as well as the combination of transformations and their representation as 4ƒ4

matrices are discussed in Appendix A.2, “Vertex Transformations”.

Back to our example: the transformation from object space to world space is put into a 4ƒ4 matrix, which is also

known as “model matrix” (since this transformation is also known as “model transformation”). This matrix is

available in the uniform parameter _Object2World, which is defined and used in the following shader:

Shader "Cg shading in world space" {

SubShader {

Pass {

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

uniform float4x4 _Object2World;

// definition of a Unity-specific uniform parameter

struct vertexInput {

float4 vertex : POSITION;

剩余328页未读，继续阅读

zhangdasi

粉丝: 48
资源: 8

Unity CG编程入门：实时3D图形与光照教程

Cg Programming in Unity.rar

Cg Programming in Unity

unity 2D Dynamic Lights and Shadows - 2DDL PRO 1.4.1.zip

CG语言学习必看

GPU编程与CG语言之阳春白雪下里巴人

Unity3D Shader教程：Cg编程入门

Unity中Cg编程入门与3D图形实操指南

Unity Shader编程入门与实践指南

Unity Shader入门指南：GPU编程实战

基于微信小程序的社区门诊管理系统php.zip

最新资源