unity3d渲染_unity3d渲染场景 - CSDN
精华内容
参与话题
  • 详解Unity3D Shader开发之渲染管线

    万次阅读 2017-01-24 21:11:04
    已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。 Shader编程对于图形学渲染来说非常重要,为了让读者理解Shader编程的原理,文章会结合着可编程流水线原理...

    笔者介绍:姜雪伟IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀编辑,畅销书作者,国家专利发明人;已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。

    Shader编程对于图形学渲染来说非常重要,为了让读者理解Shader编程的原理,文章会结合着可编程流水线原理与Shader编程一起给读者介绍,游戏场景中的物体渲染都是基于可编程流水线实现的,大家可以想象一下游戏开发使用的是美术制作的3D模型然后将其加入到游戏场景中进行渲染,其实就是把绘制的3D物体通过可编程流水线绘制在2D的屏幕上的过程,为了能让读者真正的了解其实现原理,下面文字会结合着图片一起讲解,首先介绍流程图如下所示:


    图中流程是将3D模型通过渲染绘图管线处理也就是中间显示的黑盒子,最后在屏幕上绘制出2D图片。接下来给读者介绍渲染管线流程,它可以细分为:顶点处理,面处理,光栅化,像素处理,图示如下所示:


    先介绍渲染管线的中的顶点处理,顶点处理就是通过一系列的坐标系转换,将模型的顶点在摄像机前进行位移,并最终将模型投影到摄像机的屏幕上。坐标系的流程图如下所示:


    这一系列变换会涉及到各个坐标系中的矩阵变换,再将顶点变换给读者完整的展现一次,效果如下所示:


    在这一阶段包括顶点的坐标变换、逐顶点雾化、材质属性和光照属性处理。接下来介绍面处理,面处理主要包括:

    面的组装,面截取,面剔除,整个流程如下所示:


    以3D模型为例,3D模型就是有点组成的,然后程序将点连成线,然后对其进行裁剪处理。在3D中模型的组装方式有很多种,效果如下所示:


    这些点和线的绘制在DX中都有现成的接口调用。点线绘制完成后接下来开始对面进行剔除操作,在使用Unity开发中使用摄像机使可以很容易观察到物体的裁剪,效果如下所示:


    面剔除完成后,接下来就需要进行光栅化操作了,先把效果图给读者展示一下:


    其实在进行光栅化操作时,我们显示的物体都是有材质渲染的,这就涉及到像素处理,像素处理主要包括:对每个像素区域进行着色,对像素贴上贴图,最后形成最终的画面。


    讲了这么多,我们需要知道面剔除操作是在渲染管线的哪个部分进行的,将渲染管线中的处理细化一下,效果如下所示:


    渲染管线的流程是在GPU中进行的,展示效果如下所示:


    如果读者使用DirectX开发过Demo,对3D调用接口应该比较熟悉,下面结合着图片把在CPU中调用的接口对应到GPU使用的接口,展示效果如下所示:


    渲染管线主要分为四个步骤:顶点变换,图元装配,光栅化,像素处理,再结合着图片给读者介绍如下:


    Shader编程主要是分为两部分:一部分是顶点处理,一部分是像素处理。

    顶点处理:

    顶点渲染的作用是对三维图元的顶点进行坐标变换和光照计算,生成可用于渲染到投影空间的顶点坐标、颜色和纹理坐标。顶点渲染就是定义了一系列针对顶点的渲染指令或渲染语句,当Direct3D处理图元顶点时,自动使用这些渲染指令或者渲染语句对每一个顶点逐一进行处理,完成顶点数据的处理工作。

    再说说像素处理:

    对每个像素的颜色斤西瓜混合纹理采样,包括迭代颜色和纹理坐标、纹理采样以及将纹理采样与灯光和材质的颜色进行混合。比如:Alpha测试、深度测试、模版测试、计算每个像素的雾化值、Alpha混合等。

    下面把DirectX的完整代码给读者展示一下,使用的都是DX的接口,完整代码如下所示:

    //============================================================================
    // Desc: 纹理阶段混合状态
    //============================================================================
    #include <d3dx9.h>
    
    
    //-----------------------------------------------------------------------------
    // Desc: 全局变量
    //-----------------------------------------------------------------------------
    LPDIRECT3D9               g_pD3D        = NULL;  //Direct3D对象
    LPDIRECT3DDEVICE9         g_pd3dDevice  = NULL;  //Direct3D设备对象
    LPDIRECT3DVERTEXBUFFER9   g_pVB         = NULL;  //顶点缓冲区对象
    LPDIRECT3DTEXTURE9        g_pTexture    = NULL;  //纹理对象
    
    
    //-----------------------------------------------------------------------------
    // Desc: 顶点结构
    //-----------------------------------------------------------------------------
    struct CUSTOMVERTEX
    {
        D3DXVECTOR3 position;   //顶点位置
        D3DXVECTOR3 normal;     //顶点法线
    	FLOAT       tu, tv;     //顶点纹理坐标
    };
    #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_TEX1)
    
    
    //-----------------------------------------------------------------------------
    // Desc: 设置变换矩阵
    //-----------------------------------------------------------------------------
    VOID SetupMatrices()
    {
        //建立并设置世界矩阵
        D3DXMATRIXA16 matWorld;
        D3DXMatrixIdentity( &matWorld );
        g_pd3dDevice->SetTransform( D3DTS_WORLD, &matWorld );
    
    	//建立并设置观察矩阵
        D3DXVECTOR3 vEyePt( 0.0f, 3.0f,-5.0f );
        D3DXVECTOR3 vLookatPt( 0.0f, 0.0f, 0.0f );
        D3DXVECTOR3 vUpVec( 0.0f, 1.0f, 0.0f );
        D3DXMATRIXA16 matView;
        D3DXMatrixLookAtLH( &matView, &vEyePt, &vLookatPt, &vUpVec );
        g_pd3dDevice->SetTransform( D3DTS_VIEW, &matView );
    
        //建立并设置投影矩阵
        D3DXMATRIXA16 matProj;
        D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
        g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );
    }
    
    
    //-----------------------------------------------------------------------------
    // Desc: 初始化Direct3D
    //-----------------------------------------------------------------------------
    HRESULT InitD3D( HWND hWnd )
    {
        //创建Direct3D对象, 该对象用于创建Direct3D设备对象
        if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
            return E_FAIL;
    
    	//设置D3DPRESENT_PARAMETERS结构, 准备创建Direct3D设备对象
        D3DPRESENT_PARAMETERS d3dpp;
        ZeroMemory( &d3dpp, sizeof(d3dpp) );
        d3dpp.Windowed = TRUE;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
        d3dpp.EnableAutoDepthStencil = TRUE;
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    
        //创建Direct3D设备对象
        if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                          D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                          &d3dpp, &g_pd3dDevice ) ) )
        {
            return E_FAIL;
        }
    
    	//设置渲染状态
        g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE ); //剔除模式设置
        g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );          //启用深度测试
    	g_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, TRUE);     //启用镜面反射光照模型
    
    	//设置纹理渲染状态
    	g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );  //默认设置
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
    	
        g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );
    
    	//设置纹理过滤方式
    	g_pd3dDevice->SetSamplerState( 0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
    	g_pd3dDevice->SetSamplerState( 0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
    
    	//设置变换矩阵
    	SetupMatrices();
    
        return S_OK;
    }
    
    
    //-----------------------------------------------------------------------------
    // Desc: 设置材质和灯光
    //-----------------------------------------------------------------------------
    VOID SetupLight()
    {
    	 //设置材质
        D3DMATERIAL9 mtrl;
        ZeroMemory( &mtrl, sizeof(D3DMATERIAL9) );
        mtrl.Diffuse.r = mtrl.Ambient.r = 1.0f;
        mtrl.Diffuse.g = mtrl.Ambient.g = 1.0f;
        mtrl.Diffuse.b = mtrl.Ambient.b = 1.0f;
        mtrl.Diffuse.a = mtrl.Ambient.a = 1.0f;
        g_pd3dDevice->SetMaterial( &mtrl );
    
        //设置灯光
        D3DXVECTOR3 vecDir;
        D3DLIGHT9 light;
        ZeroMemory( &light, sizeof(D3DLIGHT9) );
        light.Type       = D3DLIGHT_DIRECTIONAL;
        light.Diffuse.r  = 1.0f;
        light.Diffuse.g  = 1.0f;
        light.Diffuse.b  = 1.0f;
        vecDir = D3DXVECTOR3(cosf(timeGetTime()/350.0f),
                             1.0f,
                             sinf(timeGetTime()/350.0f) );
        D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecDir );
        light.Range       = 1000.0f;
        g_pd3dDevice->SetLight( 0, &light );
        g_pd3dDevice->LightEnable( 0, TRUE );
        g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, TRUE ); //默认设置
    
        //设置环境光
        g_pd3dDevice->SetRenderState( D3DRS_AMBIENT, 0x00808080 );
    }
    
    
    //-----------------------------------------------------------------------------
    // Desc: 创建场景图形(纹理和顶点缓冲区)
    //-----------------------------------------------------------------------------
    HRESULT InitGeometry()
    {
    	//创建纹理对象
    	if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice, L"texture.jpg", &g_pTexture ) ) )
        {
           MessageBox(NULL, L"创建纹理失败", L"Texture.exe", MB_OK);
           return E_FAIL;
        }
    
        //创建顶点缓冲区
        if( FAILED( g_pd3dDevice->CreateVertexBuffer( 50*2*sizeof(CUSTOMVERTEX),
                                                      0, D3DFVF_CUSTOMVERTEX,
                                                      D3DPOOL_DEFAULT, &g_pVB, NULL ) ) )
        {
            return E_FAIL;
        }
    
        //填充顶点缓冲区
        CUSTOMVERTEX* pVertices;
        if( FAILED( g_pVB->Lock( 0, 0, (void**)&pVertices, 0 ) ) )
            return E_FAIL;
        for( DWORD i=0; i<50; i++ )
        {
            FLOAT theta = (2*D3DX_PI*i)/(50-1);
            pVertices[2*i+0].position = D3DXVECTOR3( sinf(theta),-1.0f, cosf(theta) );
            pVertices[2*i+0].normal   = D3DXVECTOR3( sinf(theta), 0.0f, cosf(theta) );
    		pVertices[2*i+0].tu       = ((FLOAT)i)/(50-1);
            pVertices[2*i+0].tv       = 1.0f;
    
            pVertices[2*i+1].position = D3DXVECTOR3( sinf(theta), 1.0f, cosf(theta) );
            pVertices[2*i+1].normal   = D3DXVECTOR3( sinf(theta), 0.0f, cosf(theta) );
    		pVertices[2*i+1].tu       = ((FLOAT)i)/(50-1);
            pVertices[2*i+1].tv       = 0.0f;
        }
        g_pVB->Unlock();
    
        return S_OK;
    }
    
    
    //-----------------------------------------------------------------------------
    // Name: 释放创建的对象
    //-----------------------------------------------------------------------------
    VOID Cleanup()
    {
    	//释放纹理对象
    	 if( g_pTexture != NULL )
            g_pTexture->Release();
    
    	//释放顶点缓冲区对象
        if( g_pVB != NULL )
            g_pVB->Release();
    
    	//释放Direct3D对象
        if( g_pd3dDevice != NULL )
            g_pd3dDevice->Release();
    
    	//释放Direct3D对象
        if( g_pD3D != NULL )
            g_pD3D->Release();
    }
    
    
    //-----------------------------------------------------------------------------
    // Desc: 渲染图形 
    //-----------------------------------------------------------------------------
    VOID Render()
    {
        //清除后缓冲区和深度缓冲区
        g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
                             D3DCOLOR_XRGB(45, 50, 170), 1.0f, 0 );
    
        //开始在后台缓冲区绘制图形
        if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
        {
    		//设置材料和灯光, 因为灯光属性不断变化,所以在此设置
    		SetupLight(); 
    
    		//在后台缓冲区绘制图形
    		g_pd3dDevice->SetTexture( 0, g_pTexture );  //设置纹理
            g_pd3dDevice->SetStreamSource( 0, g_pVB, 0, sizeof(CUSTOMVERTEX) );
            g_pd3dDevice->SetFVF( D3DFVF_CUSTOMVERTEX );
            g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLESTRIP, 0, 2*50-2 );
    
            //结束在后台缓冲区绘制图形
            g_pd3dDevice->EndScene();
        }
    
    	//将在后台缓冲区绘制的图形提交到前台缓冲区显示
        g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
    }
    
    
    //-----------------------------------------------------------------------------
    // Desc: 消息处理
    //-----------------------------------------------------------------------------
    LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
    {
    	switch( msg )
    	{
    	case WM_DESTROY:
    		Cleanup();
    		PostQuitMessage( 0 );
    		return 0;
    	}
    
        return DefWindowProc( hWnd, msg, wParam, lParam );
    }
    
    
    //--------------------------------------------------------
    // Desc: 入口函数
    //--------------------------------------------------------
    INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
    {
        //注册窗口类
        WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                          GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                          L"ClassName", NULL };
        RegisterClassEx( &wc );
    
        //创建窗口
        HWND hWnd = CreateWindow( L"ClassName", L"纹理阶段混合状态",
                                  WS_OVERLAPPEDWINDOW, 200, 100, 500, 500,
                                  GetDesktopWindow(), NULL, wc.hInstance, NULL );
    
        //初始化Direct3D
        if( SUCCEEDED( InitD3D( hWnd ) ) )
        {
            //创建场景图形
            if( SUCCEEDED( InitGeometry() ) )
            {
                //显示窗口
                ShowWindow( hWnd, SW_SHOWDEFAULT );
                UpdateWindow( hWnd );
    
                //进入消息循环
                MSG msg;
                ZeroMemory( &msg, sizeof(msg) );
                while( msg.message!=WM_QUIT )
                {
                    if( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
                    {
                        TranslateMessage( &msg );
                        DispatchMessage( &msg );
                    }
                    else
    				{
                        Render();  //渲染图形
    				}
                }
            }
        }
    
        UnregisterClass( L"ClassName", wc.hInstance );
        return 0;
    }
    
    这些操作都是在CPU中进行的,下面对应的是在Unity3D shader中的代码,Shader代码如下所示:

    Shader "Custom/RenderPipeline" {
    	
    	Properties {
    		_Color ("Main Color", Color) = (1, 1, 1, 1)
    		_MainTex ("Base (RGB)", 2D) = "white" {}
    	}
    	SubShader {
    
    		Pass{
    		// Dont write to the depth buffer
    		ZWrite off
    
    		// Set up alpha blending
    		Blend SrcAlpha OneMinusSrcAlpha
    
    		CGPROGRAM
    		#pragma vertex vert
    		#pragma fragment frag
    		#include "UnityCG.cginc"
    
    		sampler2D _MainTex;
    		float4 _Color;
    
    		struct v2f{
    			float4 pos:SV_POSITION;
    			float4 texcoord : TEXCOORD0;
    		};
    
    		v2f vert(appdata_base v)
    		{
    			v2f o;
    			o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
    			o.texcoord = v.texcoord;
    			return o;
    		}
    
    		half4 frag(v2f i):COLOR0
    		{
    			half4 col = _Color * tex2D(_MainTex, i.texcoord.xy);
    			return col;
    		}
    
    		ENDCG
    		}
    	} 
    	FallBack "Diffuse"
    }

    关于渲染管线的介绍,就讲到这里,主要是通过图片的描述让读者知道渲染管线是如何工作的。结合着DirectX和Unity3D Shader也是告诉读者CPU和GPU之间的对应关系,文中展示的Unity3D Shader相对来说比较简单,Shader中的模型视图投影矩阵的表示为UNITY_MATRIX_MVP,mul表示的是将模型顶点转换到投影矩阵中。。。。。。



    
    
    展开全文
  • Unity3D引擎之高级渲染技术

    万次阅读 2017-01-05 15:01:35
    和《Unity3D实战核心技术详解》电子工业出版社等书籍 在游戏开发中尤其对于角色的材质渲染一直是被游戏开发者所看重,也成为衡量游戏品质的一个指标,关于渲染就需要考虑到Shader编程,Shader主要是对模型的顶点...

    笔者介绍:姜雪伟,IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀编辑,畅销书作者,国家专利发明人,已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社 和《Unity3D实战核心技术详解》电子工业出版社等书籍

    在游戏开发中尤其对于角色的材质渲染一直是被游戏开发者所看重,也成为衡量游戏品质的一个指标,关于渲染就需要考虑到Shader编程,Shader主要是对模型的顶点和模型的材质图片做处理,下面告诉读者如何去编写Shader。

    在公司,策划需求提出用Unity3D引擎实现角色材质高光、法线效果。策划需求提出后,美术首先用PS和MAX工具将模型制作出来,MAX中有自身带的Shader,它可以完整的实现高光、法线效果,这也是程序编写和调试Shader时的参照依据,程序是参照MAX中的效果去调试,程序实现的效果只能无限接近MAX工具制作的效果。Unity5.4以上版本也有自己的高光法线Shader,但是在使用时效果并不理想,不如自己去实现一下。在这里首先需要提供三张贴图:Diffuse(原图),Specular(高光),Normal(法线)。









    接下来就需要对其进行Shader编程实现,为了让美术调试方便,在这里我们使用了控制面板。首先实现一个继承于Materal类的编辑器脚本,将其放到Editor文件夹下面,内容如下所示:


    using System.Collections.Generic;
    using UnityEngine;
    using UnityEditor;
    using System.Linq;
    using System.Text.RegularExpressions;
    
    public abstract class CustomMaterialEditor : MaterialEditor
    {
    	public class FeatureEditor
    	{
    		// The name the toggle will have in the inspector.
    		public string InspectorName;
    		// We will look for properties that contain this word, and hide them if we're not enabled.
    		public string InspectorPropertyHideTag;
    		// The keyword that the shader uses when this feature is enabled or disabled.
    		public string ShaderKeywordEnabled;
    		public string ShaderKeywordDisabled;
    		// The current state of this feature.
    		public bool Enabled;
    
    		public FeatureEditor(string InspectorName, string InspectorPropertyHideTag, string ShaderKeywordEnabled, string ShaderKeywordDisabled)
    		{
    			this.InspectorName = InspectorName;
    			this.InspectorPropertyHideTag = InspectorPropertyHideTag;
    			this.ShaderKeywordEnabled = ShaderKeywordEnabled;
    			this.ShaderKeywordDisabled = ShaderKeywordDisabled;
    			this.Enabled = false;
    		}
    	}
    
    	// A list of all the toggles that we have in this material editor.
    	protected List<FeatureEditor> Toggles = new List<FeatureEditor>();
    	// This function will be implemented in derived classes, and used to populate the list of toggles.
    	protected abstract void CreateToggleList(); 
    
    	public override void OnInspectorGUI ()
    	{
    		// if we are not visible... return
    		if (!isVisible)
    			return;
    
    		// Get the current keywords from the material
    		Material targetMat = target as Material;
    		string[] oldKeyWords = targetMat.shaderKeywords;
    
    		// Populate our list of toggles
    		//Toggles.Clear();
    		Toggles = new List<FeatureEditor>();
    		CreateToggleList();
    
    		// Update each toggle to enabled if it's enabled keyword is present. If it's enabled keyword is missing, we assume it's disabled.
    		for(int i = 0; i < Toggles.Count; i++)
    		{
    			Toggles[i].Enabled = oldKeyWords.Contains (Toggles[i].ShaderKeywordEnabled);
    		}
    
    		// Begin listening for changes in GUI, so we don't waste time re-applying settings that haven't changed.
    		EditorGUI.BeginChangeCheck();
    
    		serializedObject.Update ();
    		var theShader = serializedObject.FindProperty ("m_Shader");
    		if (isVisible && !theShader.hasMultipleDifferentValues && theShader.objectReferenceValue != null)
    		{
    			float controlSize = 64;
    			EditorGUIUtility.labelWidth = Screen.width - controlSize - 20;
    			EditorGUIUtility.fieldWidth = controlSize;
    
    			Shader shader = theShader.objectReferenceValue as Shader;
    
    			EditorGUI.BeginChangeCheck();
    
    			// Draw Non-toggleable values
    			for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
    			{
    				ShaderPropertyImpl(shader, i, null);
    			}
    			// Draw toggles, then their values.
    			for (int s = 0; s < Toggles.Count; s++)
    			{
    				EditorGUILayout.Separator();
    				Toggles[s].Enabled = EditorGUILayout.BeginToggleGroup(Toggles[s].InspectorName, Toggles[s].Enabled);
    
    				if (Toggles[s].Enabled)
    				{
    					for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
    					{
    						ShaderPropertyImpl(shader, i, Toggles[s]);
    					}
    				}
    				EditorGUILayout.EndToggleGroup();
    			}
    
    			if (EditorGUI.EndChangeCheck())
    				PropertiesChanged ();
    		}
    
    		// If changes have been made, then apply them.
    		if (EditorGUI.EndChangeCheck())
    		{
    			// New list of key words.
    			List<string> newKeyWords = new List<string>();
    
    			// If true, add the enabled keyword (ending with _ON), if false, add the disabled keyword(ending with _OFF).
    			for(int i = 0; i < Toggles.Count; i++)
    			{
    				newKeyWords.Add(Toggles[i].Enabled ? Toggles[i].ShaderKeywordEnabled : Toggles[i].ShaderKeywordDisabled);
    			}
    
    			// Send the new list of keywords to the material, this will define what version of the shader to use.
    			targetMat.shaderKeywords = newKeyWords.ToArray ();
    			EditorUtility.SetDirty (targetMat);
    		}
    	}
    
    	// This runs once for every property in our shader.
    	private void ShaderPropertyImpl(Shader shader, int propertyIndex, FeatureEditor currentToggle)
    	{
    		string propertyDescription = ShaderUtil.GetPropertyDescription(shader, propertyIndex);
    
    		// If current toggle is null, we only want to show properties that aren't already "owned" by a toggle,
    		// so if it is owned by another toggle, then return.
    		if (currentToggle == null)
    		{
    			for (int i = 0; i < Toggles.Count; i++)
    			{
    				if (Regex.IsMatch(propertyDescription, Toggles[i].InspectorPropertyHideTag , RegexOptions.IgnoreCase))
    				{
    					return;
    				}
    			}
    		}
    		// Only draw if we the current property is owned by the current toggle.
    		else if (!Regex.IsMatch(propertyDescription, currentToggle.InspectorPropertyHideTag , RegexOptions.IgnoreCase))
    		{
    			return;
    		}
    		// If we've gotten to this point, draw the shader property regulairly.
    		ShaderProperty(shader,propertyIndex);
    	}
    }
    


    上面是我们自己实现的可以作为父类使用,其实就是做了一个接口封装,下面代码是自己定义的为我们自己的Shader脚本操作写的几个开关。如下所示:


    using System.Collections.Generic;
    using UnityEngine;
    using UnityEditor; 
    
    public class EditorInspector : CustomMaterialEditor
    {
        protected override void CreateToggleList()
        {
            Toggles.Add(new FeatureEditor("Normal Enabled","normal","NORMALMAP_ON","NORMALMAP_OFF"));
            Toggles.Add(new FeatureEditor("Specular Enabled","specular","SPECULAR_ON","SPECULAR_OFF"));
            Toggles.Add(new FeatureEditor("Fresnel Enabled","fresnel","FRESNEL_ON","FRESNEL_OFF"));
            Toggles.Add(new FeatureEditor("Rim Light Enabled","rim","RIMLIGHT_ON","RIMLIGHT_OFF"));
        }
    } 
    

    相对来说比较简单,它只是做了几个Toggle作为Shader脚本中的控制。将上述两个文件拖放到Editor文件夹下面。

      下面才开始真正的Shader编写工作,在这里我们使用了SurfaceOutput作为我们的输出结构体,SurfaceOutput简单地描述了surface的属性(  properties of the surface ),如反射率颜色(albedo color)、法线(normal)、散射(emission)、镜面反射(specularity )等。首先定义一个输入结构体如下所示:

    struct Input
            {
                float2 uv_DiffuseMap;
                #if SPECULAR_ON
                float2 uv_SpecMap;
                #endif
                #if NORMALMAP_ON
                float2 uv_NormalMap;
                #endif
                #if FRESNEL_ON || RIMLIGHT_ON
                float3 viewDir;
                #endif
            }; 
    

    结构体中包含 Diffuse贴图的uv坐标uv_DiffuseMap,高光的uv坐标uv_SpecMap,法线的uv坐标uv_NormalMap,另外还定义了一个方向值viewDir。接下来就是实现主函数surf了,对于高光法线的渲染就在这里面了,它调用了大量的CG库函数,如下所示:

     void surf (Input IN, inout SurfaceOutput o)
            {  
                float3 TexData = tex2D(_DiffuseMap, IN.uv_DiffuseMap);
                float3 _BlendColor =  _TintColor.rgb * _TintColorMultiply;
                 
                o.Albedo.rgb = _Brightness * lerp(TexData, _TintColor.rgb, _TintColorMultiply) ;
                 
                #if SPECULAR_ON
                o.Specular = _Gloss;
                o.Gloss = max(_SpecAdd + _SpecularMultiply, 1.0) * tex2D (_SpecMap, IN.uv_SpecMap);
                //o.Emission = _Gloss * tex2D (_SpecMap, IN.uv_SpecMap);
                #endif
                #if NORMALMAP_ON
                o.Normal = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
                #endif
             
                #if FRESNEL_ON && SPECULAR_ON || RIMLIGHT_ON
                float facing = saturate(1.0 - max(dot(normalize(IN.viewDir), normalize(o.Normal)), 0.0));
     
                    #if FRESNEL_ON && SPECULAR_ON
                    float fresnel = max(_FresnelBias + (1.0-_FresnelBias) * pow(facing, _FresnelPower), 0);
                    fresnel = fresnel * o.Specular * _FresnelMultiply;
                    o.Gloss *= 1+fresnel;
                    #endif        
                    #if RIMLIGHT_ON
                    float rim = max(_RimBias + (1.0-_RimBias) * pow(facing, _RimPower), 0);
                    rim = rim * o.Specular * _RimMultiply;
                    o.Albedo *= 1+rim;
                    #endif
                #endif
             
            } 
    

    下面将Shader的完整代码展示如下:


    Shader "Custom_Shaders/DNSRender"
    {
        Properties
        {
            _TintColor ("Color Tint",color) = (1.0,1.0,1.0,1.0)
            //Diffuse Sliders
            _TintColorMultiply("Color Tint Multiply", Range(0.0, 1.0)) = 0.0
            _Brightness ("Diffuse Brightness", Range(0.0, 2.0)) = 1.0
            _DiffuseMap ("Diffuse (RGB)", 2D) = "white" {}
            _NormalMap ("Normal Map(RGB)", 2D) = "bump" {}
            _SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
            _SpecularMultiply ("Specular Brightness",float) = 1.0
            _SpecAdd ("Specular Boost", float) = 0
            _SpecMap ("Specular Map (RGB)", 2D) = "grey" {}
            _Gloss ("Specular Glossiness", float) = 0.5
            _FresnelPower ("Fresnel Power",float) = 1.0
            _FresnelMultiply ("Fresnel Multiply", float) = 0.2
            _FresnelBias ("Fresnel Bias", float) = -0.1
            _RimPower ("RimLight Power",float) = 1.0
            _RimMultiply ("RimLight Multiply", float) = 0.2
            _RimBias ("RimLight Bias", float) = 0
            _EmissionColor("Emission Color", color) = (1.0,1.0,1.0,1.0)
        }
        SubShader
        {
            Tags { "RenderType"="Opaque" }
            LOD 300
            CGPROGRAM
            #pragma surface surf BlinnPhong
            #pragma target 3.0
            #pragma shader_feature NORMALMAP_ON NORMALMAP_OFF
            #pragma shader_feature SPECULAR_ON SPECULAR_OFF
            #pragma shader_feature FRESNEL_ON FRESNEL_OFF
            #pragma shader_feature RIMLIGHT_ON RIMLIGHT_OFF
            float3 _TintColor;
            float _TintColorMultiply;
            float _Brightness;
    
            sampler2D _DiffuseMap;
            sampler2D _NormalMap;    
            sampler2D _SpecMap;
    
            float _SpecularMultiply;
            float _SpecAdd;
            float _Gloss;
            float _FresnelPower;
            float _FresnelMultiply;
            float _FresnelBias;
            float _RimPower;
            float _RimMultiply;
            float _RimBias;
            float3 _EmissionColor;
    
            struct Input
            {
                float2 uv_DiffuseMap;
                #if SPECULAR_ON
                float2 uv_SpecMap;
                #endif
                #if NORMALMAP_ON
                float2 uv_NormalMap;
                #endif
                #if FRESNEL_ON || RIMLIGHT_ON
                float3 viewDir;
                #endif
            };
     
            void surf (Input IN, inout SurfaceOutput o)
            {  
                float3 TexData = tex2D(_DiffuseMap, IN.uv_DiffuseMap);
                float3 _BlendColor =  _TintColor.rgb * _TintColorMultiply;
     			
                o.Albedo.rgb = _Brightness * lerp(TexData, _TintColor.rgb, _TintColorMultiply) ;
     			
                #if SPECULAR_ON
                o.Specular = _Gloss;
                o.Gloss = max(_SpecAdd + _SpecularMultiply, 1.0) * tex2D (_SpecMap, IN.uv_SpecMap);
                //o.Emission = _Gloss * tex2D (_SpecMap, IN.uv_SpecMap);
                #endif
                #if NORMALMAP_ON
                o.Normal = UnpackNormal(tex2D(_NormalMap, IN.uv_NormalMap));
                #endif
             
                #if FRESNEL_ON && SPECULAR_ON || RIMLIGHT_ON
                float facing = saturate(1.0 - max(dot(normalize(IN.viewDir), normalize(o.Normal)), 0.0));
     
                    #if FRESNEL_ON && SPECULAR_ON
                    float fresnel = max(_FresnelBias + (1.0-_FresnelBias) * pow(facing, _FresnelPower), 0);
                    fresnel = fresnel * o.Specular * _FresnelMultiply;
                    o.Gloss *= 1+fresnel;
                    #endif        
                    #if RIMLIGHT_ON
                    float rim = max(_RimBias + (1.0-_RimBias) * pow(facing, _RimPower), 0);
                    rim = rim * o.Specular * _RimMultiply;
                    o.Albedo *= 1+rim;
                    #endif
                #endif
             
            }
            ENDCG
        }
    
        CustomEditor "EditorInspector"
    }
     
    

    将Shader挂接到材质球上效果如下:




    最终展示效果如下所示:



    展开全文
  • 虽然RenderTexture这个技术是个普遍使用的技术,但是用好它还是要理解他的底层原理和避免一些使用的问题。这里就UNITY3d中的RenderTexure介绍Rendertexture的底层原理和使用时可能遇到的坑和效率问题。

    本文中大部分例子将按照Opengles的实现来解释

    1.RenderTexture是什么


         在U3D中有一种特殊的Texture类型,叫做RenderTexture,它本质上一句话是将一个FrameBufferObjecrt连接到一个server-side的Texture对象。

         什么是server-sider的texture?

         在渲染过程中,贴图最开始是存在cpu这边的内存中的,这个贴图我们通常称为client-side的texture,它最终要被送到gpu的存储里,gpu才能使用它进行渲染,送到gpu里的那一份被称为server-side的texture。这个tex在cpu和gpu之间拷贝要考虑到一定的带宽瓶颈。

         什么是FrameBufferObject?

         FrameBuffer就是gpu里渲染结果的目的地,我们绘制的所有结果(包括color depth stencil等)都最终存在这个这里,有一个默认的FBO它直接连着我们的显示器窗口区域,就是把我们的绘制物体绘制到显示器的窗口区域。但是现代gpu通常可以创建很多其他的FBO,这些FBO不连接窗口区域,这种我们创建的FBO的存在目的就是允许我们将渲染结果保存在gpu的一块存储区域,待之后使用,这是一个非常有用的东西。

        当渲染的结果被渲染到一个FBO上后,就有很多种方法得到这些结果,我们能想想的使用方式就是把这个结果作为一个Texture的形式得到,通常有这样几种方式得到这个贴图:

        a) 将这个FBO上的结果传回CPU这边的贴图,在gles中的实现一般是ReadPixels()这样的函数,这个函数是将当前设为可读的FBO拷贝到cpu这边的一个存储buffer,没错如果当前设为可读的FBO是那个默认FBO,那这个函数就是在截屏,如果是你自己创建的FBO,那就把刚刚绘制到上面的结果从gpu存储拿回内存。

       b)   将这个FBO上的结果拷贝到一个gpu上的texture,在gles中的实现一般是CopyTexImage2D(),它一般是将可读的FBO的一部分拷贝到存在于gpu上的一个texture对象中,直接考到server-sider就意味着可以马上被gpu渲染使用

      c)  将这个fbo直接关联一个gpu上的texture对象,这样就等于在绘制时就直接绘制到这个texure上,这样也省去了拷贝时间,gles中一般是使用FramebufferTexture2D()这样的接口。

      

      那么unity的RenderTexture正是这种c)方式的一种实现,它定义了在server-side的一个tex对象,然后将渲染直接绘制到这个tex上。

      这有什么用?

      我们可以将场景的一些渲染结果渲染到一个tex上,这个tex可以被继续使用。例如,汽车的后视镜,后视镜就可以贴一个rendertex,它是从这个视角的摄像机渲染而来。

      我们还可以利用这个进行一些图像处理操作,传统的图像处理在cpu中一个for循环,一次处理一个像素,如果我们渲染一个四方形,然后把原图当成tex传入进去,写一个fragment shader,将渲染的结果渲染到一个rendertex上,那么rendertex上的东西就是图像处理的结果,unity中的一些图像后处理效果(如模糊,hdr等)就是这样做的。


    2.渲染到RenderTexture的几种方式


     1.在assets里创建一个RenderTexture,然后将其附给一个摄像机,这样这个摄像机实时渲染的结果就都在这个tex上了。

     2.有的时候我们想人为的控制每一次渲染,你可以将这个摄像机disable掉,然后手动的调用一次render。

     3. 有的时候我们想用一个特殊的shader去渲染这个RenderTexture,那可以调用cam的RenderWithShader这个函数,它将使用你指定的shader去渲染场景,这时候场景物体上原有的shader都将被自动替换成这个shader,而参数会按名字传递。这有什么用?比如我想得到当前场景某个视角的黑白图,那你就可以写个渲染黑白图的shader,调用这个函数。(这里还有一个replacement shader的概念,不多说,看下unity文档)

     4. 我们还可以不用自己在assets下创建rendertexture,直接使用Graphics.Blit(src, target, mat)这个函数来渲染到render texture上,这里的的target就是你要绘制的render texrture,src是这个mat中需要使用的_mainTex,可以是普通tex2d,也可以是另一个rendertex,这个函数的本质是,绘制一个四方块,然后用mat这个材质,用src做maintex,然后先clear为black,然后渲染到target上。这个是一个快速的用于图像处理的方式。我们可以看到UNITY的很多后处理的一效果就是一连串的Graphics.Blit操作来完成一重重对图像的处理,如果在cpu上做那几乎是会卡死的。

        

    3.从rendertex获取结果


     大部分情况我们渲染到rt就是为了将其作为tex继续给其他mat使用。这时候我们只需把那个mat上调用settexture传入这个rt就行,这完全是在gpu上的操作。

    但有的时候我们想把它拷贝回cpu这边的内存,比如你想保存成图像,你想看看这个图什么样,因为直接拿着rt你并不能得到它的每个pixel的信息,因为他没有内存这一侧的信息。Texture2d之所以有,是因为对于选择了read/write属性的tex2D,它会保留一个内存这边的镜像。这种考回就是1部分写的a)方式,把rt从gpu拷贝回内存,注意这个操作不是效率很高。copy回的方法通常是这样的

                Texture2D uvtexRead = new Texture2D()

                RennderTexture currentActiveRT = RenderTexture.active;
                // Set the supplied RenderTexture as the active one
                RenderTexture.active = uvTex;
                uvtexRead.ReadPixels(new Rect(0, 0, uvTexReadWidth, uvTexReadWidth), 0, 0);
                RenderTexture.active = currentActiveRT;

    上面这段代码就是等于先把当前的fbo设为可读的对象,然后调用相关操作将其读回内存。

    4.其他的一些问题


    1.rendertexture的格式,rt的格式和普通的tex2D的格式并不是一回事,我们查阅文档,看到rt的格式支持的有很多种,最基本的ARGB32是肯定支持的,很多机器支持ARRBHALF或者ARGBFLOAT这样的格式,这种浮点格式是很有用的,想象一下你想把场景的uv信息保存在一张图上,你要保存的就不是256的颜色,而是一个个浮点数。但是使用前一定要查询当前的gpu支持这种格式

    2.如果你想从RenderTexture拷贝回到内存,那么rt和拷贝回来的tex的格式必须匹配,且必须是rgba32或者RGBA24这种基本类型,你把float拷贝回来应该是不行的

    3.rendertexture的分配和销毁,如果你频繁的要new一个rt出来,那么不要直接new,而是使用RenderTexture提供的GetTemporaryReleaseTemporary,它将在内部维护一个池,反复重用一些大小格式一样的rt资源,因为让gpu为你分配一个新的tex其实是要耗时间的。更重要的这里还会调用DiscardContents

    4 DiscardContents()这个rendertex的接口非常重要,好的习惯是你应该尽量在每次往一个已经有内容的rt上绘制之前总是调用它的这个DiscardContents函数,大致得到的优化是,在一些基于tile的gpu上,rt和一些tile的内存之间要存在着各种同步, 如果你准备往一个已经有内容的rt上绘制,将触发到这种同步,而这个函数告诉gpu这块rt的内容不用管他了,我反正是要重新绘制,这样就避免了这个同步而产生的巨大开销。总之还是尽量用GetTemporray这个接口吧,它会自动为你处理这个事情


    可以看到虽然RenderTexture这个技术是个普遍使用的技术,但是用好它还是要理解他的底层原理和避免一些使用的问题。

    欢迎大家就这个问题进行更多讨论

    
    展开全文
  • Unity3D引擎之渲染技术系列一

    千次阅读 2017-04-02 10:57:13
    已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。CSDN视频网址:http://edu.csdn.net/lecturer/144 在学习Unity引擎或者是其他3D游戏引擎时,经常遇到的...

    笔者介绍:姜雪伟,IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀编辑,畅销书作者,国家专利发明人;已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社等。

    CSDN视频网址:http://edu.csdn.net/lecturer/144

    在学习Unity引擎或者是其他3D游戏引擎时,经常遇到的问题就是各个坐标空间,在以前的博客中也给读者介绍过,本篇博客里用通俗易懂的语言再给读者揭露一下为什么需要这么多坐标空间?以及如何产生矩阵变换或者说利用矩阵变换解决问题。

    在生活中我们经常遇到问路的,有的人方向感比较强,而有的人方向感比较弱,针对这些人指路时就要注意了,方向感强的人,你可以告诉他向东走大约300米,再向北走100米,你给他说的这些就是以东南西北为坐标轴介绍的,方向感弱的人,你就不能这么说了,你只能说向向前走300米,再向左走100米,这时你使用的是以这个路人围原点的坐标空间,通过这个案例,你可以看到不同的指路方式对应的就是我们不同的坐标轴向。由此可见,我们在生活中在不同的情况下使用不同的坐标空间,这个跟游戏中使用不同的空间是类似的。

    Unity3D引擎开发3D游戏时,也会面临着各个坐标空间的变换,在这里给读者普及一下,这样开发者再做一些空间变换时更容易上手。Unity3D引擎使用的是扩展名为FBX的模型,模型的制作是美术人员用建模工具Max制作完成导出的,除了模型还包括图片,比如高光,法线等,关于材质的渲染可以使用Unity3D自带的Shader或者自己编写Shader。制作的模型相对于它自身而言就是局部空间也称为模型空间,也称为局部空间,每个模型都有自己独立的坐标空间。当它移动或者旋转时,模型空间也会跟着它移动和旋转。打个形象比喻,我们在公司的房间里面移动时,我们自身的空间也在跟着移动,当我们转身时,我们的坐标空间也在跟随变化。

    在模型制作时,美术人员会给模型一个坐标,默认的情况下都是设置成(0,0,0),这个坐标是作为父节点的坐标,模型会有自己的孩子节点,假设带有孩子节点的物体如下图所示:

    孩子节点的坐标是(2,2,0),它是子物体的局部坐标,下面会通过矩阵转换的方式,计算一下它在Unity中的世界坐标,也是高速读者如何利用矩阵变换获取到在世界空间的世界坐标。在Unity3D引擎使用的是左手坐标系也就是Z轴朝里,X轴朝右,Y轴朝上。将我们制作好的模型拖入到Unity编辑器后的效果如下所示:

    红色箭头表示的是X轴,绿色的箭头表示的是Y轴,蓝色的箭头表示的是Z轴。它在世界场景中的坐标是(0,0,0)换句话说就是它自身的局部坐标与世界坐标重合。它的孩子节点是我们上面提到过的,下面我们将模型进行位移,旋转,缩放进行操作,我们进行缩放(2,2,2),旋转(0,150,0),位移(5,0,25),在Unity的表现效果如下所示:


    我们可以构建出模型变换矩阵,在这里要注意一个问题,它们变换的顺序是一定的,不能改变。先进行缩放,在进行旋转,最后进行位移操作。相应的矩阵变换如下所示:


    接下来我们对模型的子物体进行模型变换如下:


    也就是说,在世界空间下,模型的子孩子的位置是(9,4,18.0)这样我们通过矩阵变换就得到了子孩子的世界坐标,其实这些基本运算我们在游戏开发中也是经常使用的,比如我们可以自己利用矩阵变换实现实时阴影,Unity3D自带的阴影由于消耗比较大,不容易在移动端实现,我们自己可以利用矩阵变换实现,效率得到提升。

    后面继续介绍观察空间的矩阵实现。













    展开全文
  • Unity3D 渲染操作

    2019-08-27 20:56:20
    步骤: 第一步: 先创建【纹理文件夹“Textures”】和【渲染文件夹“Material”】,并且存放纹理图片 【创建】渲染对象 ...【选择】shader处理方式,Legacy ...【拖拽】渲染对象,给物体对象一个渲染方式 ...
  • Unity3D Shader 渲染流程

    千次阅读 2018-09-14 16:37:56
    Shader渲染流程是CPU和GPU合作渲染一帧的过程,绘制过程分为三个阶段: 应用程序阶段(CPU控制)、几何阶段(GPU控制)、光栅化阶段(GPU控制) 应用程序阶段:主要进行CPU和内存的算法。在这个阶段的主要工作是...
  • Unity3d轻量渲染管线(LWRP)民间文档

    万次阅读 2019-02-23 17:31:12
    近日在学习Unity3d的SRP,由于官方未正式发布,故几乎没有文档支持,考虑到官方一贯的风格,即使正式发布了,估计Shader部分也不会有详尽的文档。所以,干脆自己在研究学习源码之余,写了一份文档,既加深自己的理解...
  • 有时候在 游戏中,我们会需要在UI上面显示3d模型(例如角色选择、装备选择、装备预览等等),这时候我们就要用到RenderTexture和UI里面的RawImage。具体做法就是新建一个RenderTexture资源,将它命名为texture_1好了...
  • 其实3D物体基本不用考虑渲染顺序问题,但是在纯2D以及3D和2D混杂的情况下就要...事实上这个问题unity3d自身已经提供了解决方案。 http://docs.unity3d.com/ScriptReference/Renderer.html 我们可以看到,所有的Rende
  • Unity实现水面渲染效果

    千次阅读 2019-03-29 16:16:34
    镜面反射 将摄像机的位置和视锥体关于镜面进行对称变换,渲染一张RenderTexture。在渲染水面时,计算水面某像素在屏幕中的位置,根据该位置对RenderTexture进行采样。 ...Unity3D教程:实现水...
  • unity5.3多线程渲染的坑

    千次阅读 2016-08-16 10:46:58
    之前无意中开启了多线程渲染的选项,发现UGUI那边开始出现显示乱的情况,特此做个标记,有遇到这个问题的,知道怎么解决
  • 3ds Max 烘焙模型导入 Unity 3D 步骤

    万次阅读 2016-05-23 20:53:25
    3ds Max 建的宿舍模型导入 Unity 3D 步骤总结。
  • Unity3D Linear和Gamma渲染

    千次阅读 2017-08-17 11:31:37
    IT公司技术合伙人,IT高级讲师,CSDN社区专家,特邀编辑,畅销书作者,已出版书籍:《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社,《Cocos2d-x 3.x图形学渲染技术讲解》...
  • Unity3D】3dsmax中带Vray材质的3D模型的导入

    万次阅读 多人点赞 2017-07-07 21:03:50
    相信做3D的人,不可能没听过3dsmax,至少你不是做美工的,也知道白富美的美工MM就是用...可惜的是,Vray是3dsmax一个插件,这个渲染器由于光影效果过于逼真,渲染一张图常常需要几秒~几分钟,而Unity3d有自己的渲染器,
  • Unity之在UI界面上显示3D模型

    万次阅读 2017-02-04 18:30:01
    1、创建一个3D摄像机,渲染3D模型。(我为了方便就把模型放到了Camera的下面,你可以不这样) 2、在2D里面指定一个TopLeft和BottomRight,用来表示模型渲染到UI上面的区域。 3、在之前的3D摄像机...
  • Unity中的层级以及渲染顺序

    千次阅读 2017-10-17 22:05:16
    在使用unity3d开发游戏项目时,层级的问题往往伴随着UI的开发,而在引入了3D模型、粒子特效后,层级的问题就变得有些扑朔迷离了,甚至会牵扯到Unity的渲染顺序。本篇主要从UGUI的角度出发,浅析UGUI中影响层级的因素...
  • Unity3D-实现水墨渲染效果

    千次阅读 2016-12-23 17:01:14
    原文:http://gad.qq.com/user/myarticle?id=438905
  • 一句话总结Unity物体渲染先后顺序

    千次阅读 2019-12-31 13:14:15
    依次按条件先后顺序进行排序渲染处理。先按上层条件排序,如上层条件相同,则进入下层条件牌序,最终分出先后 Camera Depth: 越小越优先 |---1.RenderQueue 2500已下(含2500),优先于RenderQueue 2500已上 |---...
  • unity3d使用octane gpu渲染场景体验

    千次阅读 2017-08-30 09:17:47
    测试了一下u3d下的octane渲染器 目前是免费的,可以随意测试 之前提到过了http://blog.csdn.net/shenmifangke/article/details/76577647 现在赶紧过来试试 我测试电脑是win7 gtx1080 记得提前把显卡驱动之类打好 ...
  • Unity 3D - Camera Play [摄像机渲染特效]

    千次阅读 2018-01-22 21:30:10
    Unity 3D - Camera Play [摄像机渲染特效] : 下载地址 : 下载地址点这里 (http://download.csdn.net/download/yu__jiaoshou/9991133) 作用 : 非常实用的插件 , 基本都是一行代码搞定一个特效 , 可以多特效...
1 2 3 4 5 ... 20
收藏数 19,153
精华内容 7,661
关键字:

unity3d渲染