AddMatrix() private method

private AddMatrix ( int nameID, Matrix4x4 value ) : void
nameID int
value Matrix4x4
return void
 static public int AddMatrix(IntPtr l)
 {
     try {
         int argc = LuaDLL.lua_gettop(l);
         if (matchType(l, argc, 2, typeof(int), typeof(UnityEngine.Matrix4x4)))
         {
             UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l);
             System.Int32 a1;
             checkType(l, 2, out a1);
             UnityEngine.Matrix4x4 a2;
             checkValueType(l, 3, out a2);
             self.AddMatrix(a1, a2);
             pushValue(l, true);
             return(1);
         }
         else if (matchType(l, argc, 2, typeof(string), typeof(UnityEngine.Matrix4x4)))
         {
             UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l);
             System.String a1;
             checkType(l, 2, out a1);
             UnityEngine.Matrix4x4 a2;
             checkValueType(l, 3, out a2);
             self.AddMatrix(a1, a2);
             pushValue(l, true);
             return(1);
         }
         pushValue(l, false);
         LuaDLL.lua_pushstring(l, "No matched override function to call");
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
 void Start()
 {
     property_block = new MaterialPropertyBlock();
     property_block.AddMatrix("prev_Object2World", Matrix4x4.identity);
     mesh_renderer = GetComponent<MeshRenderer>();
     mesh_renderer.SetPropertyBlock(property_block);
 }
 static public int AddMatrix(IntPtr l)
 {
     try{
         if (matchType(l, 2, typeof(System.String), typeof(UnityEngine.Matrix4x4)))
         {
             UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l);
             System.String a1;
             checkType(l, 2, out a1);
             UnityEngine.Matrix4x4 a2;
             checkType(l, 3, out a2);
             self.AddMatrix(a1, a2);
             return(0);
         }
         else if (matchType(l, 2, typeof(System.Int32), typeof(UnityEngine.Matrix4x4)))
         {
             UnityEngine.MaterialPropertyBlock self = (UnityEngine.MaterialPropertyBlock)checkSelf(l);
             System.Int32 a1;
             checkType(l, 2, out a1);
             UnityEngine.Matrix4x4 a2;
             checkType(l, 3, out a2);
             self.AddMatrix(a1, a2);
             return(0);
         }
         LuaDLL.luaL_error(l, "No matched override function to call");
         return(0);
     }
     catch (Exception e) {
         LuaDLL.luaL_error(l, e.ToString());
         return(0);
     }
 }
 public void AddToMaterialPropertyBlock(MaterialPropertyBlock block)
 {
     UIPanelMaterialPropertyBlock.Node node = this.first;
     int num = this.count;
     while (true)
     {
         int num1 = num;
         num = num1 - 1;
         if (num1 <= 0)
         {
             break;
         }
         switch (node.type)
         {
             case UIPanelMaterialPropertyBlock.PropType.Float:
             {
                 block.AddFloat(node.property, [email protected]);
                 break;
             }
             case UIPanelMaterialPropertyBlock.PropType.Vector:
             {
                 block.AddVector(node.property, [email protected]);
                 break;
             }
             case UIPanelMaterialPropertyBlock.PropType.Color:
             {
                 block.AddColor(node.property, [email protected]);
                 break;
             }
             case UIPanelMaterialPropertyBlock.PropType.Matrix:
             {
                 block.AddMatrix(node.property, [email protected]);
                 break;
             }
         }
         node = node.next;
     }
 }
Beispiel #5
0
		private void ApplyToBlock(ref MaterialPropertyBlock block, ShaderIDs bids) {
			#if USE_PROPERTY_BLOCKS
			block.AddVector(bids.exposureIBL,	exposures);
			block.AddVector(bids.exposureLM,	exposuresLM);

			block.AddMatrix(bids.skyMatrix,		skyMatrix);
			block.AddMatrix(bids.invSkyMatrix,	invMatrix);

			block.AddVector(bids.skyMin, skyMin);
			block.AddVector(bids.skyMax, skyMax);			

			if(specularCube) block.AddTexture(bids.specCubeIBL, specularCube);
			else 			 block.AddTexture(bids.specCubeIBL, blackCube);

			block.AddVector(bids.SH[0],	SH.cBuffer[0]);
			block.AddVector(bids.SH[1],	SH.cBuffer[1]);
			block.AddVector(bids.SH[2],	SH.cBuffer[2]);
			block.AddVector(bids.SH[3],	SH.cBuffer[3]);
			block.AddVector(bids.SH[4],	SH.cBuffer[4]);
			block.AddVector(bids.SH[5],	SH.cBuffer[5]);
			block.AddVector(bids.SH[6],	SH.cBuffer[6]);
			block.AddVector(bids.SH[7],	SH.cBuffer[7]);
			block.AddVector(bids.SH[8], SH.cBuffer[8]);

			#endif
		}
Beispiel #6
0
        //public Vector3					prevMotionTranslation;
        public SkinnedData(SkinnedMeshRenderer smr)
        {
            renderer = smr;
            materialCount = renderer.sharedMaterials.Length;
            bakedMesh = new Mesh();
            bakedMesh.MarkDynamic();
            #if !USE_BAKEPOSONLY
            smr.BakeMesh(bakedMesh);
            bakedPrevPos = bakedMesh.vertices;
            #else
            smr.BakeMeshPositionsOnly(bakedMesh, true);
            Mesh.CopyChannel(bakedMesh, bakedMesh, MeshChannel.Vertex, MeshChannel.Normal);
            #endif
            props = new MaterialPropertyBlock();
            props.AddMatrix(SID_PREV_MVP, Matrix4x4.identity);
            prevWorld = renderer.transform.localToWorldMatrix;

            motionTransform = renderer.transform;
            for(var t = motionTransform.parent; t; t = t.parent) {
                var c = t.GetComponent<MoBlurSkinRigidBinding>();
                if(c) {
                    motionTransform = c.motionRoot;
                    break;
                }
            }
        }
Beispiel #7
0
        public RigidData(MeshRenderer mr)
        {
            var mf = mr.GetComponent<MeshFilter>();
            if(mf == null)
                throw new UnityException("Encountered MeshRenderer without matching MeshFilter! " + mr.name);

            transform = mr.transform;
            renderer = mr;
            mesh = mf.sharedMesh;
            materials = mr.sharedMaterials;
            if(mesh == null || materials == null)
                materials = new Material[0];
            else if(materials.Length > mesh.subMeshCount)	// Cut off any redundant materials in the renderer
                System.Array.Resize(ref materials, mesh.subMeshCount);
            props = new MaterialPropertyBlock();
            props.AddMatrix(SID_PREV_MVP, Matrix4x4.identity);
            prevWorld = transform.localToWorldMatrix;
        }
Beispiel #8
0
        protected virtual void SetScreenUniforms(TerrainNode node, TerrainQuad quad, MaterialPropertyBlock matPropertyBlock)
        {
            double ox = quad.GetOX();
            double oy = quad.GetOY();
            double l = quad.GetLength();

            Vector3d2 p0 = new Vector3d2(ox, oy, 0.0);
            Vector3d2 p1 = new Vector3d2(ox + l, oy, 0.0);
            Vector3d2 p2 = new Vector3d2(ox, oy + l, 0.0);
            Vector3d2 p3 = new Vector3d2(ox + l, oy + l, 0.0);

            Matrix4x4d corners = new Matrix4x4d(p0.x, p1.x, p2.x, p3.x,
                                                p0.y, p1.y, p2.y, p3.y,
                                                p0.z, p1.z, p2.z, p3.z,
                                                1.0, 1.0, 1.0, 1.0);

            matPropertyBlock.AddMatrix(m_uniforms.screenQuadCorners, (m_localToScreen * corners).ToMatrix4x4());

            Matrix4x4d verticals = new Matrix4x4d(	0.0, 0.0, 0.0, 0.0,
                                                  0.0, 0.0, 0.0, 0.0,
                                                  1.0, 1.0, 1.0, 1.0,
                                                  0.0, 0.0, 0.0, 0.0);

            matPropertyBlock.AddMatrix(m_uniforms.screenQuadVerticals, (m_localToScreen * verticals).ToMatrix4x4());
        }
Beispiel #9
0
        /**
        * Sets the shader uniforms that are necessary to project on screen the
        * given TerrainQuad. This method can set the uniforms that are specific to
        * the given quad.
        */
        public virtual void SetUniforms(TerrainNode node, TerrainQuad quad, MaterialPropertyBlock matPropertyBlock)
        {
            if(matPropertyBlock == null || node == null || quad == null) return;

            double ox = quad.GetOX();
            double oy = quad.GetOY();
            double l = quad.GetLength();
            double distFactor = (double)node.GetDistFactor();
            int level = quad.GetLevel();

            matPropertyBlock.AddVector(m_uniforms.offset, new Vector4((float)ox, (float)oy, (float)l, (float)level));

            Vector3d2 camera = node.GetLocalCameraPos();

            matPropertyBlock.AddVector(m_uniforms.camera, new Vector4(	(float)((camera.x - ox) / l), (float)((camera.y - oy) / l),
                                                                      (float)((camera.z - node.GetView().GetGroundHeight()) / (l * distFactor)),
                                                                      (float)camera.z));

            Vector3d2 c = node.GetLocalCameraPos();

            Matrix3x3d m = m_localToTangent * (new Matrix3x3d(l, 0.0, ox - c.x, 0.0, l, oy - c.y, 0.0, 0.0, 1.0));

            matPropertyBlock.AddMatrix(m_uniforms.tileToTangent, m.ToMatrix4x4());

            SetScreenUniforms(node, quad, matPropertyBlock);
        }
        protected override void SetScreenUniforms(TerrainNode node, TerrainQuad quad, MaterialPropertyBlock matPropertyBlock)
        {
            double ox = quad.GetOX();
            double oy = quad.GetOY();
            double l = quad.GetLength();

            Vector3d2 p0 = new Vector3d2(ox, oy, R);
            Vector3d2 p1 = new Vector3d2(ox + l, oy, R);
            Vector3d2 p2 = new Vector3d2(ox, oy + l, R);
            Vector3d2 p3 = new Vector3d2(ox + l, oy + l, R);
            Vector3d2 pc = (p0 + p3) * 0.5;

            double l0 = 0.0, l1 = 0.0, l2 = 0.0, l3 = 0.0;
            Vector3d2 v0 = p0.Normalized(ref l0);
            Vector3d2 v1 = p1.Normalized(ref l1);
            Vector3d2 v2 = p2.Normalized(ref l2);
            Vector3d2 v3 = p3.Normalized(ref l3);

            Matrix4x4d deformedCorners = new Matrix4x4d(v0.x * R, v1.x * R, v2.x * R, v3.x * R,
                                                        v0.y * R, v1.y * R, v2.y * R, v3.y * R,
                                                        v0.z * R, v1.z * R, v2.z * R, v3.z * R,
                                                        1.0, 1.0, 1.0, 1.0);

            matPropertyBlock.AddMatrix(m_uniforms.screenQuadCorners, (m_localToScreen * deformedCorners).ToMatrix4x4());

            Matrix4x4d deformedVerticals = new Matrix4x4d(	v0.x, v1.x, v2.x, v3.x,
                                                          v0.y, v1.y, v2.y, v3.y,
                                                          v0.z, v1.z, v2.z, v3.z,
                                                          0.0, 0.0, 0.0, 0.0);

            matPropertyBlock.AddMatrix(m_uniforms.screenQuadVerticals, (m_localToScreen * deformedVerticals).ToMatrix4x4());
            matPropertyBlock.AddVector(m_uniforms.screenQuadCornerNorms, new Vector4((float)l0, (float)l1, (float)l2, (float)l3));

            Vector3d2 uz = pc.Normalized();
            Vector3d2 ux = (new Vector3d2(0,1,0)).Cross(uz).Normalized();
            Vector3d2 uy = uz.Cross(ux);

            Matrix4x4d ltow = node.GetLocalToWorld();

            Matrix3x3d tangentFrameToWorld = new Matrix3x3d(ltow.m[0,0], ltow.m[0,1], ltow.m[0,2],
                                                            ltow.m[1,0], ltow.m[1,1], ltow.m[1,2],
                                                            ltow.m[2,0], ltow.m[2,1], ltow.m[2,2]);

            Matrix3x3d m = new Matrix3x3d(	ux.x, uy.x, uz.x,
                                          ux.y, uy.y, uz.y,
                                          ux.z, uy.z, uz.z);

            matPropertyBlock.AddMatrix(m_uniforms.tangentFrameToWorld, (tangentFrameToWorld * m).ToMatrix4x4());
        }