internal void DrawSpriteGlyph(Texture2D texture, Vector4 dest, Vector4 source, Color color)
        {
            if (!m_DrawString_InProgress)
                Logging.Fatal("BeginDrawString() must be called before DrawSpriteGlyph()");

            Vector4 uv = new Vector4(
                (float)source.X / texture.Width,
                (float)source.Y / texture.Height,
                (float)(source.X + source.Z) / texture.Width,
                (float)(source.Y + source.W) / texture.Height);

            VertexPositionTextureHueExtra[] v = new VertexPositionTextureHueExtra[4]
            {
                new VertexPositionTextureHueExtra(new Vector3(dest.X, dest.Y, m_DrawString_Depth), new Vector2(uv.X, uv.Y), color, Vector4.Zero), // top left
                new VertexPositionTextureHueExtra(new Vector3(dest.X + dest.Z, dest.Y, m_DrawString_Depth), new Vector2(uv.Z, uv.Y), color, Vector4.Zero), // top right
                new VertexPositionTextureHueExtra(new Vector3(dest.X, dest.Y + dest.W, m_DrawString_Depth), new Vector2(uv.X, uv.W), color, Vector4.Zero), // bottom left
                new VertexPositionTextureHueExtra(new Vector3(dest.X + dest.Z, dest.Y + dest.W, m_DrawString_Depth), new Vector2(uv.Z, uv.W), color, Vector4.Zero) // bottom right
            };

            /*if (shadow != null)
            {
                Color shadow2 = new Color(
                    shadow.Value.R, shadow.Value.G,
                    shadow.Value.B, 128);
                for (int i = 0; i < 4; i++)
                {
                    VertexPositionTextureHueExtra v0 = v[i];
                    v0.Hue = shadow.Value;
                    v0.Position.Y += 1f;
                    m_DrawString_VertexList.Add(v0);
                }
            }*/
            for (int i = 0; i < 4; i++)
                m_DrawString_VertexList.Add(v[i]);
        }
 public void ApplyDamage(Vector4 mg)
 {
     if (mg.w>maxhp) {
         Global.score+=points;
         Instantiate(explosion,transform.position,transform.rotation);
         Destroy(gameObject);
     }
     else {
         hp-=mg.w;
         if (hp<=0) {
             Instantiate(Resources.Load<GameObject>("bigdust"),transform.position,Quaternion.identity);
             RaycastHit rh;
             var layerMask=1<<11; //waterlayer
                 if (Physics.Raycast(transform.position,Vector3.down,out rh,200,layerMask)) {
                     Instantiate(oil_spot,rh.point,Quaternion.Euler(0,Random.value*360,0));
             }
             Global.score+=points;
             Destroy(gameObject);
         }
         else {
             if (hp/maxhp<0.25f&&!broken) {
                 broken=true;
                 GameObject x=Instantiate(Resources.Load<GameObject>("fire1"),transform.position,Quaternion.identity) as GameObject;
                 x.transform.parent=transform;
                 x=Instantiate(Resources.Load<GameObject>("smoke"),transform.position,Quaternion.identity) as GameObject;
                 x.transform.parent=transform;
                 foreach (GameObject g in buildings) {
                     Destroy(g);
                 }
             }
         }
     }
 }
   public void In(
      [FriendlyName("A", "The first variable or variable list.")]
      Vector4[] A,

      [FriendlyName("B", "The second variable or variable list.")]
      Vector4[] B,

      [FriendlyName("Result", "The Vector4 result of the operation.")]
      out Vector4 Result
      )
   {
      Vector4 aTotals = new Vector4(0, 0, 0, 0);
      Vector4 bTotals = new Vector4(0, 0, 0, 0);

      foreach (Vector4 currentA in A)
      {
         aTotals += currentA;
      }
      foreach (Vector4 currentB in B)
      {
         bTotals += currentB;
      }

      Result = aTotals + bTotals;
   }
    public void ApplyDamage(Vector4 mg)
    {
        if (mg.w>maxhp) {
            Global.menu_script.AddFireplace(transform.position);
            Global.score+=points;
            Destroy(gameObject);
        }
        else {
            hp-=mg.w;
            if (hp<=0) {
                if (use_dust) {
                    Vector3 p=null_point;
                    while (tall>0) {
                        p+=transform.TransformDirection(Vector3.up*10);
                        Global.BigDustRequest(p);
                        tall-=10;
                    }
                }

                Destroy(gameObject);
            }

        }
        if (hp<cd) {
            GameObject x=Instantiate(Global.r_fire,new Vector3(mg.x,mg.y,mg.z),Quaternion.LookRotation(new Vector3(mg.x,mg.y,mg.z)-transform.position)) as GameObject;
            x.transform.parent=transform;
            if (cd>0) cd-=fd;
        }
    }
Beispiel #5
0
        public Effect(XElement element)
        {
            if (element.Attribute("id") != null)
                Id = element.Attribute("id").Value;
            if (element.Attribute("name") != null)
                Name = element.Attribute("name").Value;

            var commonElement = element.Element(XName.Get("profile_COMMON", COLLADAConverter.Namespace));
            if (commonElement != null)
            {
                var techniqueElement = commonElement.Element(XName.Get("technique", COLLADAConverter.Namespace));
                if (techniqueElement != null)
                {
                    var phongElement = techniqueElement.Element(XName.Get("phong", COLLADAConverter.Namespace));
                    if (phongElement != null)
                    {
                        Emission = XmlReaderHelper.ReadColor(phongElement.Element(XName.Get("emission", COLLADAConverter.Namespace)).Element(XName.Get("color", COLLADAConverter.Namespace)));
                        Ambient = XmlReaderHelper.ReadColor(phongElement.Element(XName.Get("ambient", COLLADAConverter.Namespace)).Element(XName.Get("color", COLLADAConverter.Namespace)));
                        Specular = XmlReaderHelper.ReadColor(phongElement.Element(XName.Get("specular", COLLADAConverter.Namespace)).Element(XName.Get("color", COLLADAConverter.Namespace)));
                        Shininess = XmlReaderHelper.ReadFloat(phongElement.Element(XName.Get("shininess", COLLADAConverter.Namespace)).Element(XName.Get("float", COLLADAConverter.Namespace)));
                        Reflectivity = XmlReaderHelper.ReadFloat(phongElement.Element(XName.Get("reflectivity", COLLADAConverter.Namespace)).Element(XName.Get("float", COLLADAConverter.Namespace)));
                        Transparent = XmlReaderHelper.ReadColor(phongElement.Element(XName.Get("transparent", COLLADAConverter.Namespace)).Element(XName.Get("color", COLLADAConverter.Namespace)));
                        Transparency = XmlReaderHelper.ReadFloat(phongElement.Element(XName.Get("transparency", COLLADAConverter.Namespace)).Element(XName.Get("float", COLLADAConverter.Namespace)));

                        var diffuseElement = phongElement.Element(XName.Get("diffuse", COLLADAConverter.Namespace));
                        var diffuseColorElement = diffuseElement.Element(XName.Get("color", COLLADAConverter.Namespace));
                        if (diffuseColorElement != null)
                            Diffuse = XmlReaderHelper.ReadColor(diffuseColorElement);
                    }
                }
            }
        }
Beispiel #6
0
 /// 行列との掛け算
 public static Vector4 Mult( ref Vector4 pos, Matrix4 mtx )
 {
     calPos4.X = (mtx.M11 * pos.X) + (mtx.M21 * pos.Y) + ( mtx.M31 * pos.Z ) + ( mtx.M41 * pos.W );
     calPos4.Y = (mtx.M12 * pos.X) + (mtx.M22 * pos.Y) + ( mtx.M32 * pos.Z ) + ( mtx.M42 * pos.W );
     calPos4.Z = (mtx.M13 * pos.X) + (mtx.M23 * pos.Y) + ( mtx.M33 * pos.Z ) + ( mtx.M43 * pos.W );
     return calPos4;
 }
Beispiel #7
0
        public override IEnumerator Run()
        {
            m_max = QueryDisplacements.MaxRange(m_displacements, m_choppyness, m_gridScale, this);

            FinishedRunning();
            return null;
        }
 public VertexVoxel(Vector3 pos, Vector2 uv, Vector4 uvr, Color c)
 {
     Position = pos;
     UV = uv;
     UVRect = uvr;
     Tint = c;
 }
    void Raymarch(int width, int height, Vector4 lightPos)
    {
        SetFrustumRays(m_RaymarchMaterial);

        int shadowmapWidth = m_Shadowmap.width;
        int shadowmapHeight = m_Shadowmap.height;

        Graphics.SetRenderTarget(m_RaymarchedLightEpi.colorBuffer, m_RaymarchedLightEpi.depthBuffer);
        GL.Clear(false, true, new Color(0, 0, 0, 1));
        m_RaymarchMaterial.SetTexture("_Coord", m_CoordEpi);
        m_RaymarchMaterial.SetTexture("_InterpolationEpi", m_InterpolationEpi);
        m_RaymarchMaterial.SetTexture("_Shadowmap", m_Shadowmap);
        float brightness = m_Colored ? m_BrightnessColored/m_ColorBalance : m_Brightness;
        brightness *= m_Light.intensity;
        m_RaymarchMaterial.SetFloat("_Brightness", brightness);
        m_RaymarchMaterial.SetFloat("_Extinction", -m_Extinction);
        m_RaymarchMaterial.SetVector("_ShadowmapDim", new Vector4(shadowmapWidth, shadowmapHeight, 1.0f / shadowmapWidth, 1.0f / shadowmapHeight));
        m_RaymarchMaterial.SetVector("_ScreenTexDim", new Vector4(width, height, 1.0f / width, 1.0f / height));
        m_RaymarchMaterial.SetVector("_LightColor", m_Light.color.linear);
        m_RaymarchMaterial.SetFloat("_MinDistFromCamera", m_MinDistFromCamera);
        SetKeyword(m_Colored, "COLORED_ON", "COLORED_OFF");
        m_RaymarchMaterial.SetTexture("_ColorFilter", m_ColorFilter);
        SetKeyword(m_AttenuationCurveOn, "ATTENUATION_CURVE_ON", "ATTENUATION_CURVE_OFF");
        m_RaymarchMaterial.SetTexture("_AttenuationCurveTex", m_AttenuationCurveTex);
        Texture cookie = m_Light.cookie;
        SetKeyword(cookie != null, "COOKIE_TEX_ON", "COOKIE_TEX_OFF");
        if (cookie != null)
            m_RaymarchMaterial.SetTexture("_Cookie", cookie);
        m_RaymarchMaterial.SetPass(0);

        RenderQuadSections(lightPos);
    }
Beispiel #10
0
 public void Vector4_ConstructFromVector3Test()
 {
     Vector3 v3 = new Vector3(1.0f, 2.0f, 3.0f);
     Vector4 v4 = new Vector4(v3, 0.8f);
     Vector4 expected = new Vector4(v3.x, v3.y, v3.z, 0.8f);
     Assert.AreEqual(expected, v4);
 }
Beispiel #11
0
 public static Vector4 smokeyCalc(Vector4 a, Vector4 b, double t)
 {
     return new Vector4(smokeyCalc(a.X, b.X, t),
                        smokeyCalc(a.Y, b.Y, t),
                        smokeyCalc(a.Z, b.Z, t),
                        smokeyCalc(a.W, b.W, t));
 }
Beispiel #12
0
 public VertexPositionNormal4Texture(Vector3 position, Vector3 normal, Vector4 textureWeight, Vector4 textureType)
 {
     Position = position;
     Normal = normal;
     TextureWeight = textureWeight;
     TextureType = textureType;
 }
    void Update()
    {
        if (Input.GetKey(KeyCode.L)) {
            if (!L_downflag) {
                L_downflag=true;
                if (dlight.shadows==LightShadows.None) {
                    dlight.shadows=LightShadows.Soft;
                } else {
                    dlight.shadows=LightShadows.None;
                }
            }
        } else {
            L_downflag=false;
        }

        Material mat=grass.renderer.material;
        Collider col=grass.collider;

        Ray ray = new Ray(rigidbody.position+Vector3.up, -Vector3.up);
        RaycastHit hit=new RaycastHit();
        if (col.Raycast(ray, out hit, 100f)) {
            float dmp=Mathf.Clamp(1-(rigidbody.position.y-0.3042075f)/0.35f,0,1);
            Vector4 pos=new Vector4(hit.textureCoord.x, hit.textureCoord.y, dmp*dmp, 0);
            mat.SetVector("_ballpos", pos);
            rigidbody.drag=dmp*1.0f;
            float v=rigidbody.velocity.magnitude*5.0f;
            dmp/=(v<1) ? 1 : v;
            rigidbody.angularDrag=dmp*1.0f;
        }
    }
Beispiel #14
0
 public BasicVec4(Vector4 v)
 {
     x = v.X;
     y = v.Y;
     z = v.Z;
     w = v.W;
 }
Beispiel #15
0
        void OnRenderImage(RenderTexture source, RenderTexture destination)
        {
            if (CheckResources() == false)
            {
                Graphics.Blit (source, destination);
                return;
            }

            Vector4 UV_Transform = new  Vector4(1, 0, 0, 1);

            #if UNITY_WP8
            // WP8 has no OS support for rotating screen with device orientation,
            // so we do those transformations ourselves.
            if (Screen.orientation == ScreenOrientation.LandscapeLeft) {
                UV_Transform = new Vector4(0, -1, 1, 0);
            }
            if (Screen.orientation == ScreenOrientation.LandscapeRight) {
                UV_Transform = new Vector4(0, 1, -1, 0);
            }
            if (Screen.orientation == ScreenOrientation.PortraitUpsideDown) {
                UV_Transform = new Vector4(-1, 0, 0, -1);
            }
            #endif

            overlayMaterial.SetVector("_UV_Transform", UV_Transform);
            overlayMaterial.SetFloat ("_Intensity", intensity);
            overlayMaterial.SetTexture ("_Overlay", texture);
            Graphics.Blit (source, destination, overlayMaterial, (int) blendMode);
        }
Beispiel #16
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Quaternion"/> class.
        /// </summary>
        /// <param name="sourcePosition">The source position.</param>
        /// <param name="destinationPosition">The destination position.</param>
        public Quaternion(Vector3 sourcePosition, Vector3 destinationPosition)
        {
            var r = sourcePosition.Cross(destinationPosition);
            var s = Functions.Sqrt(2 * (1 + sourcePosition.Dot(destinationPosition)));

            mValues = new Vector4(r / s, s / 2);
        }
   public void In(
      [FriendlyName("A", "The Vector4 to subtract from. If more than one Vector4 variable is connected to A, they will be subtracted from (0, 0, 0, 0) before B is subtracted from them.")]
      Vector4[] A,

      [FriendlyName("B", "The Vector4 to subtract from A. If more than one Vector4 variable is connected to B, they will be subtracted from (0, 0, 0, 0) before being subtracted from A.")]
      Vector4[] B,

      [FriendlyName("Result", "The Vector4 result of the subtraction operation.")]
      out Vector4 Result
      )
   {
      Vector4 aTotals = new Vector4(0, 0, 0, 0);
      Vector4 bTotals = new Vector4(0, 0, 0, 0);

      foreach (Vector4 currentA in A)
      {
         aTotals = aTotals - currentA;
      }
      foreach (Vector4 currentB in B)
      {
         bTotals = bTotals - currentB;
      }

      Result = aTotals - bTotals;
   }
		public override void BatchedUnitVectorGetSupportingVertexWithoutMargin(IList<Vector3> vectors, IList<Vector4> supportVerticesOut, int numVectors)
		{
			int i;

			Vector3 vtx = Vector3.Zero;
			float newDot = 0f;

			for (i = 0; i < numVectors; i++)
			{
				Vector4 temp = supportVerticesOut[i];
				temp.W = -MathUtil.BT_LARGE_FLOAT;
				supportVerticesOut[i] = temp;
			}


			for (int j = 0; j < numVectors; j++)
			{

				Vector3 vec = vectors[j];

				for (i = 0; i < GetNumVertices(); i++)
				{
					GetVertex(i, ref vtx);
					newDot = Vector3.Dot(vec, vtx);
					if (newDot > supportVerticesOut[j].W)
					{
						supportVerticesOut[j] = new Vector4(vtx, newDot);
					}
				}
			}


		}
Beispiel #19
0
        public override void Start()
        {
            isStarted = true;
            if (duration == 0)
            {
                sprite.SetOverlay(this.toColor);
                if (!isInfinite) this.Stop();
                return;
            }

            this.originalColor = sprite.GetOverlay();
            if (isFromNull) this.fromColor = this.originalColor;

            // velocity = UtilityHelper.CalculateVelocity(this.fromColor, this.toColor, duration);
            Sign = UtilityHelper.CalculateSign(this.fromColor, this.toColor);

            currentColor = this.fromColor;

            if (isAnimatedFromOrigin)
            {
                currentColor = this.originalColor;
                Sign = UtilityHelper.CalculateSign(currentColor, this.fromColor);
            }
            else
            {
                sprite.SetOverlay(this.currentColor);
            }

            CurrentTime = TimeSpan.Zero;
            Duration = TimeSpan.FromSeconds(duration);
            totalDistance = UtilityHelper.VectorAbs(Vector4.Subtract(toColor, fromColor));

            if (graphFunction == null)
                graphFunction = new ConstantGraphFunction(duration);
        }
 public MyGuiControlCheckbox(IMyGuiControlsParent parent, Vector2 position, Vector2 size, MyTexture2D texture, MyTexture2D checkedTexture,
     StringBuilder toolTip, bool checkedVal, Vector4 color, bool highlightWhenChecked, MyGuiControlLabel label, Vector2? innerSize = null)
     : base(parent, position, size, color, toolTip, texture, null, null, true)
 {
     m_canHandleKeyboardActiveControl = true;
     m_checked = checkedVal;
     m_highlightWhenChecked = false; // highlightWhenChecked; this feature is depracted
     m_checkedTexture = checkedTexture;
     m_label = label;
     if (m_label != null) {
         m_label.MouseEnter += delegate
         {
             m_highlight = true;
         };
         m_label.MouseLeave += delegate
         {
             m_highlight = false;
         };
         m_label.Click += delegate
         {
             UserCheck();
         };
     }
     if (innerSize == null) m_innerSize = size;
     else m_innerSize = innerSize;
 }
Beispiel #21
0
 public HslColor(Vector4 v4)
 {
     H = v4.X;
     S = v4.Y;
     L = v4.Z;
     A = v4.W;
 }
Beispiel #22
0
 public GrassV2zone(List<MaskPixRGB> pixels, Vector4 bounds, int tex = -1)
 {
     m_pixels = pixels;
     m_bounds = bounds;
     m_textureID = tex;
     m_texGen = null;
 }
Beispiel #23
0
 public Vector4(Vector4 vector)
 {
     PointsArray = new double[4];
     X = vector.X;
     Y = vector.Y;
     Z = vector.Z;
 }
 /// <summary>
 /// Compresses a position so that its components are between 0 and 1.
 /// </summary>
 /// <param name="pos">The position to compress.</param>
 /// <returns>The compressed position.</returns>
 public Vector4 CompressPosition(Vector4 pos)
 {
     var newX = (pos.X - _info.PositionMinX) / _xScale;
     var newY = (pos.Y - _info.PositionMinY) / _yScale;
     var newZ = (pos.Z - _info.PositionMinZ) / _zScale;
     return new Vector4(newX, newY, newZ, pos.W);
 }
 /// <summary>
 /// Decompresses a position so that its components are in model space.
 /// </summary>
 /// <param name="pos">The position to decompress.</param>
 /// <returns>The decompressed position.</returns>
 public Vector4 DecompressPosition(Vector4 pos)
 {
     var newX = pos.X * _xScale + _info.PositionMinX;
     var newY = pos.Y * _yScale + _info.PositionMinY;
     var newZ = pos.Z * _zScale + _info.PositionMinZ;
     return new Vector4(newX, newY, newZ, pos.W);
 }
Beispiel #26
0
        public BoundingBox Grow(Vector3 change) {
            var center = new Vector3 {
                X = (PointA.X + PointB.X) / 2f,
                Y = (PointA.Y + PointB.Y) / 2f,
                Z = (PointA.Z + PointB.Z) / 2f
            };
            var d = new Vector3 {
                X = Math.Abs(PointA.X - center.X) + change.X,
                Y = Math.Abs(PointA.Y - center.Y) + change.Y,
                Z = Math.Abs(PointA.Z - center.Z) + change.Z
            };

            var retPointA = new Vector4 {
                X = center.X + d.X,
                Y = center.Y + d.Y,
                Z = center.Z + d.Z,
                W = PointA.W
            };
            var retPointB = new Vector4 {
                X = center.X - d.X,
                Y = center.Y - d.Y,
                Z = center.Z - d.Z,
                W = PointB.W
            };

            return new BoundingBox {
                PointA = retPointA,
                PointB = retPointB
            };
        }
        /// <summary>
        /// Override PointGeometryModel3D's Attach method to 
        /// provide a buffer of DynamoPointVertices
        /// </summary>
        public override void Attach(IRenderHost host)
        {
            var techManager = host.RenderTechniquesManager;

            renderTechnique = techManager.RenderTechniques[DefaultRenderTechniqueNames.Points];
            base.Attach(host);

            if (Geometry == null)
                return;

            if (renderHost.RenderTechnique == host.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred) ||
                renderHost.RenderTechnique == host.RenderTechniquesManager.RenderTechniques.Get(DeferredRenderTechniqueNames.Deferred))
                return;

            vertexLayout = host.EffectsManager.GetLayout(renderTechnique);
            effectTechnique = effect.GetTechniqueByName(renderTechnique.Name);

            effectTransforms = new EffectTransformVariables(effect);

            var geometry = Geometry as PointGeometry3D;
            if (geometry != null)
            {          
                vertexBuffer = Device.CreateBuffer(BindFlags.VertexBuffer, VertexSizeInBytes, CreateVertexArray());
            }

            vViewport = effect.GetVariableByName("vViewport").AsVector();
            vPointParams = effect.GetVariableByName("vPointParams").AsVector();

            var pointParams = new Vector4((float)Size.Width, (float)Size.Height, (float)Figure, (float)FigureRatio);
            vPointParams.Set(pointParams);

            OnRasterStateChanged(DepthBias);

            Device.ImmediateContext.Flush();
        }
 public void Init( Vector4 av4Input )
 {
     maxXAndY.x = av4Input.z;
     maxXAndY.y = av4Input.w;
     minXAndY.x = av4Input.x;
     minXAndY.y = av4Input.y;
 }
Beispiel #29
0
 public Vertex(Vector4 position, Color4 color, Vector2 textureCoordinate, uint faceIndex)
 {
     Position = position;
     Color = color;
     TextureCoordinate = textureCoordinate;
     FaceIndex = faceIndex;
 }
      public override void DrawShaderGUI(MicroSplatShaderGUI shaderGUI, MicroSplatKeywords keywords, Material mat, MaterialEditor materialEditor, MaterialProperty[] props)
      {
         if (MicroSplatUtilities.DrawRollup("Splats"))
         {

            var albedoMap = shaderGUI.FindProp("_Diffuse", props);
            var normalMap = shaderGUI.FindProp("_NormalSAO", props);
            materialEditor.TexturePropertySingleLine(CAlbedoTex, albedoMap);
            if (!disableNormals)
            {
               if (packMode == TextureArrayConfig.PackingMode.Fastest)
               {
                  materialEditor.TexturePropertySingleLine(CNormalSpec, normalMap);
               }
               else
               {
                  materialEditor.TexturePropertySingleLine(CNormal, normalMap);
               }
            }

            if (emissiveArray && mat.HasProperty("_EmissiveMetal"))
            {
               var emisMap = shaderGUI.FindProp("_EmissiveMetal", props);
               materialEditor.TexturePropertySingleLine(CEmisMetal, emisMap);
               if (mat.HasProperty ("_EmissiveMult")) 
               {
                  var emisMult = shaderGUI.FindProp ("_EmissiveMult", props);
                  emisMult.floatValue = EditorGUILayout.Slider (CInterpContrast, emisMult.floatValue, 0.0f, 4.0f);
               }
            }

            if (packMode == TextureArrayConfig.PackingMode.Quality && mat.HasProperty("_SmoothAO"))
            {
               var smoothAO = shaderGUI.FindProp("_SmoothAO", props);
               materialEditor.TexturePropertySingleLine(CSmoothAO, smoothAO);
            }

            if (!disableHeightBlend)
            {
               var contrastProp = shaderGUI.FindProp("_Contrast", props);
               contrastProp.floatValue = EditorGUILayout.Slider(CInterpContrast, contrastProp.floatValue, 1.0f, 0.0001f);
            }


            if (!keywords.IsKeywordEnabled("_TRIPLANAR"))
            {
               EditorGUI.BeginChangeCheck();
               Vector4 uvScale = shaderGUI.FindProp("_UVScale", props).vectorValue;
               Vector2 scl = new Vector2(uvScale.x, uvScale.y);
               Vector2 offset = new Vector2(uvScale.z, uvScale.w);
               scl = EditorGUILayout.Vector2Field("Global UV Scale", scl);
               offset = EditorGUILayout.Vector2Field("Global UV Offset", offset);
               if (EditorGUI.EndChangeCheck())
               {
                  uvScale.x = scl.x;
                  uvScale.y = scl.y;
                  uvScale.z = offset.x;
                  uvScale.w = offset.y;
                  shaderGUI.FindProp("_UVScale", props).vectorValue = uvScale;
                  EditorUtility.SetDirty(mat);
               }
            }

         }
      }
Beispiel #31
0
        // Lengyel, Eric. “Computing Tangent Space Basis Vectors for an Arbitrary Mesh”.
        // Terathon Software 3D Graphics Library, 2001. http://www.terathon.com/code/tangent.html
        public static void RecalculateTangents(Mesh mesh)
        {
            var tan1 = new Vector3[mesh.vertexCount];
            var tan2 = new Vector3[mesh.vertexCount];

            for (int a = 0; a < mesh.triangles.Length; a += 3)
            {
                int i1 = mesh.triangles[a + 0];
                int i2 = mesh.triangles[a + 1];
                int i3 = mesh.triangles[a + 2];

                Vector3 v1 = mesh.vertices[i1];
                Vector3 v2 = mesh.vertices[i2];
                Vector3 v3 = mesh.vertices[i3];

                Vector2 w1 = mesh.uv[i1];
                Vector2 w2 = mesh.uv[i2];
                Vector2 w3 = mesh.uv[i3];

                float x1 = v2.x - v1.x;
                float x2 = v3.x - v1.x;
                float y1 = v2.y - v1.y;
                float y2 = v3.y - v1.y;
                float z1 = v2.z - v1.z;
                float z2 = v3.z - v1.z;

                float s1 = w2.x - w1.x;
                float s2 = w3.x - w1.x;
                float t1 = w2.y - w1.y;
                float t2 = w3.y - w1.y;

                float r    = 1.0F / (s1 * t2 - s2 * t1);
                var   sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
                                         (t2 * z1 - t1 * z2) * r);
                var tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
                                       (s1 * z2 - s2 * z1) * r);

                tan1[i1] += sdir;
                tan1[i2] += sdir;
                tan1[i3] += sdir;

                tan2[i1] += tdir;
                tan2[i2] += tdir;
                tan2[i3] += tdir;
            }

            var tangents = new Vector4[mesh.vertexCount];

            for (long a = 0; a < mesh.vertexCount; a++)
            {
                Vector3 n = mesh.normals[a];
                Vector3 t = tan1[a];

                // Gram-Schmidt orthogonalize
                tangents[a] = t - n * Vector3.Dot(n, t);
                tangents[a].Normalize();

                // Calculate handedness
                tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), tan2[a]) < 0.0f) ? -1.0f : 1.0f;
            }

            mesh.tangents = tangents;
        }
	///<summary>
	/// Input a cubemap, and then prefilter this cubemap for image-based lighting equation.
	///</summary>
	static public void PreFilterEnviromentMap(Cubemap cubemap)
	{
		if (cubemap)
		{
			int cube_width = cubemap.width;
			
			Vector3 vec3 = new Vector3();
			// Create a read buffer to store cubemap direction data.
			ComputeBuffer cubeMatrix = new ComputeBuffer(sgFaceInput.Length, Marshal.SizeOf(vec3));
			cubeMatrix.SetData(sgFaceInput);
			
			Vector4 vec4 = new Vector4();
			// Create a output buffer.
			ComputeBuffer dstData = new ComputeBuffer(cube_width * cube_width * 6, Marshal.SizeOf(vec4));
			
			ComputeShader CSEnvFilter;
			CSEnvFilter = (ComputeShader)AssetDatabase.LoadAssetAtPath("Assets/EnvironmentMapTool/ComputeShader/FilterCubeMap.compute", typeof(ComputeShader));
			// Set cubemap to shader.
			CSEnvFilter.SetTexture(0, "gCubemap", cubemap);
			// Set read write buffer for data output.
			CSEnvFilter.SetBuffer(0, "gOutput", dstData);
			// Set cubemap direction data.
			CSEnvFilter.SetBuffer(0, "sgFace2DMapping", cubeMatrix);
			
			Color[] outputData = new Color[cube_width * cube_width * 6];
			
			// How many mipmap level?
			float mipLevelNum = Mathf.Log(cube_width, 2);
			
			// Loop each mipmap level with different roughness.
			for (int i = 0; i < mipLevelNum + 1; i++)
			{
				// The texel number of a face.
				int image_size = cube_width * cube_width;
				// The texel number of a cubemap.
				int num_threads = image_size * 6;
				// Set roughness value (between 0~1).
				CSEnvFilter.SetFloat("gRoughness", (i / mipLevelNum));
				// The width of a mipmap level of a cube map.
				CSEnvFilter.SetInt("gWidth", cube_width);
				// The total number of thread groups (the number of my thread group : 64).
				num_threads = (int)Mathf.Ceil((float)num_threads / 64.0f);
				// Run compute shader.
				CSEnvFilter.Dispatch(0, num_threads, 1, 1);
				// Get data from the read & write buffer.
				dstData.GetData(outputData);
				// Copy data to the original cubemap.
				SetCubeMipMap(cubemap, outputData, image_size, i);
				// Half the size for the next mipmap level.
				cube_width = cube_width / 2;
			}
			
			// Set false to disable auto-generating mipmap.
			cubemap.Apply(false);
			// Use trilinear mode to interpolate different mipmap levels.
			cubemap.filterMode = FilterMode.Trilinear;
			cubemap.wrapMode = TextureWrapMode.Clamp;
			cubemap.name = cubemap.name + "(PreFilter)";
			
			// Release data.
			dstData.Release();
			cubeMatrix.Release();
		}
		
	}
        private bool SetShaderParameters(DeviceContext deviceContext, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, Vector4 apexColour, Vector4 centerColor)
        {
            // Transpose the matrices to prepare them for the shader.
            worldMatrix.Transpose();
            viewMatrix.Transpose();
            projectionMatrix.Transpose();

            // Lock the constant buffer so it can be written to.
            DataStream mappedResource;

            deviceContext.MapSubresource(ConstantMatrixBuffer, MapMode.WriteDiscard, MapFlags.None, out mappedResource);

            // Copy the matrices into the constant buffer.
            DMatrixBuffer matrixBuffer = new DMatrixBuffer()
            {
                world      = worldMatrix,
                view       = viewMatrix,
                projection = projectionMatrix
            };

            mappedResource.Write(matrixBuffer);

            // Unlock the constant buffer.
            deviceContext.UnmapSubresource(ConstantMatrixBuffer, 0);

            // Set the position of the constant buffer in the vertex shader.
            int bufferNumber = 0;

            // Finally set the constant buffer in the vertex shader with the updated values.
            deviceContext.VertexShader.SetConstantBuffer(bufferNumber, ConstantMatrixBuffer);

            // Lock the gradient constant buffer so it can be written to.
            deviceContext.MapSubresource(ConstantGradientBuffer, MapMode.WriteDiscard, MapFlags.None, out mappedResource);

            // Copy the gradient color variables into the constant buffer.
            DGradientBuffer gradientBuffer = new DGradientBuffer()
            {
                apexColor   = apexColour,
                centerColor = centerColor
            };

            mappedResource.Write(gradientBuffer);

            // Unlock the constant buffer.
            deviceContext.UnmapSubresource(ConstantGradientBuffer, 0);

            // Set the position of the gradient constant buffer in the pixel shader.
            bufferNumber = 0;

            // Finally set the gradient constant buffer in the pixel shader with the updated values.
            deviceContext.PixelShader.SetConstantBuffer(bufferNumber, ConstantGradientBuffer);

            return(true);
        }
        public bool Render(DeviceContext deviceContext, int indexCount, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, Vector4 apexColour, Vector4 centerColor)
        {
            // Set the shader parameters that it will use for rendering.
            if (!SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, apexColour, centerColor))
            {
                return(false);
            }

            // Now render the prepared buffers with the shader.
            RenderShader(deviceContext, indexCount);

            return(true);
        }
 protected Quaternion Vector4ToQuaternion(Vector4 rot)
 {
     return(new Quaternion(rot.x, rot.y, rot.z, rot.w));
 }
 public static Pos ToPos(this Vector4 v)
 {
     return(new Pos(v.X, v.Y, v.Z, v.W));
 }
Beispiel #37
0
 public void PackFromVector4(Vector4 vector)
 {
     this.PackedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
 }
Beispiel #38
0
        /// <summary>
        /// Gets the Brush Element Attributes from the Match
        /// </summary>
        /// <param name="match">Match object</param>
        protected override void GetAttributes(Match match)
        {
            float centerX, centerY;

            // RadiusX
            Single.TryParse(match.Groups["RadiusX"].Value, out _radiusX);
            // Sanitize by taking the absolute value
            _radiusX = Math.Abs(_radiusX);
            // RadiusY
            Single.TryParse(match.Groups["RadiusY"].Value, out _radiusY);
            // Sanitize by taking the absolute value
            _radiusY = Math.Abs(_radiusY);
            // CenterX
            Single.TryParse(match.Groups["CenterX"].Value, out centerX);
            // CenterY
            Single.TryParse(match.Groups["CenterY"].Value, out centerY);
            _center = new Vector2(centerX, centerY);

            // Opacity (optional)
            var group = match.Groups["Opacity"];

            if (group.Success)
            {
                Single.TryParse(group.Value, out _opacity);
            }
            // Origin Offset (optional)
            group = match.Groups["OriginOffset"];
            if (group.Success)
            {
                float offsetX, offsetY;
                Single.TryParse(match.Groups["OffsetX"].Value, out offsetX);
                Single.TryParse(match.Groups["OffsetY"].Value, out offsetY);
                _originOffset = new Vector2(offsetX, offsetY);
            }
            // Alpha Mode (optional)
            group = match.Groups["AlphaMode"];
            if (group.Success)
            {
                Enum.TryParse(group.Value, out _alphaMode);
            }
            // Buffer Precision (optional)
            group = match.Groups["BufferPrecision"];
            if (group.Success)
            {
                Enum.TryParse(group.Value, out _bufferPrecision);
            }
            // Edge Behavior (optional)
            group = match.Groups["EdgeBehavior"];
            if (group.Success)
            {
                Enum.TryParse(group.Value, out _edgeBehavior);
            }
            // Pre Interpolation ColorSpace (optional)
            group = match.Groups["PreColorSpace"];
            if (group.Success)
            {
                Enum.TryParse(group.Value, out _preInterpolationColorSpace);
            }
            // Post Interpolation ColorSpace (optional)
            group = match.Groups["PostColorSpace"];
            if (group.Success)
            {
                Enum.TryParse(group.Value, out _postInterpolationColorSpace);
            }
            // GradientStopHdrs
            group = match.Groups["GradientStops"];
            if (group.Success)
            {
                _gradientStopHdrs.Clear();
                foreach (Capture capture in group.Captures)
                {
                    var gradientMatch = RegexFactory.GradientStopHdrRegex.Match(capture.Value);
                    if (!gradientMatch.Success)
                    {
                        continue;
                    }

                    float position;
                    float x = 0, y = 0, z = 0, w = 0;
                    var   main = gradientMatch.Groups["Main"];
                    if (main.Success)
                    {
                        var mainMatch = RegexFactory.GetAttributesRegex(GradientStopAttributeType.MainHdr)
                                        .Match(main.Value);

                        Single.TryParse(mainMatch.Groups["Position"].Value, out position);
                        Single.TryParse(mainMatch.Groups["X"].Value, out x);
                        Single.TryParse(mainMatch.Groups["Y"].Value, out y);
                        Single.TryParse(mainMatch.Groups["Z"].Value, out z);
                        Single.TryParse(mainMatch.Groups["W"].Value, out w);

                        var color = new Vector4(x, y, z, w);

                        _gradientStopHdrs.Add(new CanvasGradientStopHdr()
                        {
                            Color    = color,
                            Position = position
                        });
                    }

                    var additional = gradientMatch.Groups["Additional"];
                    if (!additional.Success)
                    {
                        continue;
                    }

                    foreach (Capture addCapture in additional.Captures)
                    {
                        var addMatch = RegexFactory.GetAttributesRegex(GradientStopAttributeType.AdditionalHdr)
                                       .Match(addCapture.Value);
                        Single.TryParse(addMatch.Groups["Position"].Value, out position);
                        Single.TryParse(addMatch.Groups["X"].Value, out x);
                        Single.TryParse(addMatch.Groups["Y"].Value, out y);
                        Single.TryParse(addMatch.Groups["Z"].Value, out z);
                        Single.TryParse(addMatch.Groups["W"].Value, out w);

                        var color = new Vector4(x, y, z, w);

                        _gradientStopHdrs.Add(new CanvasGradientStopHdr()
                        {
                            Color    = color,
                            Position = position
                        });
                    }
                }

                // Sort the stops based on their position
                if (_gradientStopHdrs.Any())
                {
                    _gradientStopHdrs = _gradientStopHdrs.OrderBy(g => g.Position).ToList();
                }
            }
        }
Beispiel #39
0
        public void Build(List <Plane3D> Faces)
        {
            Generate();

            Mode      = Gl.GL_TRIANGLES;
            NumOfPrim = Faces.Count;

            int[]   Elements  = new int[NumOfPrim * 3];
            float[] Vertex    = new float[NumOfPrim * 9];
            float[] Normals   = new float[NumOfPrim * 9];
            float[] Colors    = new float[NumOfPrim * 12];
            float[] TexCoords = new float[NumOfPrim * 6];

            for (int j = 0; j < NumOfPrim; ++j)
            {
                int j3  = j * 3;
                int j9  = j * 9;
                int j6  = j * 6;
                int j12 = j * 12;
                Elements[j3 + 0] = j3;
                Elements[j3 + 1] = j3 + 1;
                Elements[j3 + 2] = j3 + 2;

                Vertex[j9 + 0] = (float)Faces[j].Vertex[0].X;
                Vertex[j9 + 1] = (float)Faces[j].Vertex[0].Y;
                Vertex[j9 + 2] = (float)Faces[j].Vertex[0].Z;
                Vertex[j9 + 3] = (float)Faces[j].Vertex[1].X;
                Vertex[j9 + 4] = (float)Faces[j].Vertex[1].Y;
                Vertex[j9 + 5] = (float)Faces[j].Vertex[1].Z;
                Vertex[j9 + 6] = (float)Faces[j].Vertex[2].X;
                Vertex[j9 + 7] = (float)Faces[j].Vertex[2].Y;
                Vertex[j9 + 8] = (float)Faces[j].Vertex[2].Z;

                Normals[j9 + 0] = (float)Faces[j].Normals[0].X;
                Normals[j9 + 1] = (float)Faces[j].Normals[0].Y;
                Normals[j9 + 2] = (float)Faces[j].Normals[0].Z;
                Normals[j9 + 3] = (float)Faces[j].Normals[1].X;
                Normals[j9 + 4] = (float)Faces[j].Normals[1].Y;
                Normals[j9 + 5] = (float)Faces[j].Normals[1].Z;
                Normals[j9 + 6] = (float)Faces[j].Normals[2].X;
                Normals[j9 + 7] = (float)Faces[j].Normals[2].Y;
                Normals[j9 + 8] = (float)Faces[j].Normals[2].Z;

                TexCoords[j6 + 0] = (float)Faces[j].TextureUV[0].X;
                TexCoords[j6 + 1] = (float)Faces[j].TextureUV[0].Y;
                TexCoords[j6 + 2] = (float)Faces[j].TextureUV[1].X;
                TexCoords[j6 + 3] = (float)Faces[j].TextureUV[1].Y;
                TexCoords[j6 + 4] = (float)Faces[j].TextureUV[2].X;
                TexCoords[j6 + 5] = (float)Faces[j].TextureUV[2].Y;

                Vector4 Col = Colorized ? Vector4.PerComponentProduct(Faces[j].Color, MyColor) : Faces[j].Color;

                Colors[j12 + 0]  = (float)Col.X;
                Colors[j12 + 1]  = (float)Col.Y;
                Colors[j12 + 2]  = (float)Col.Z;
                Colors[j12 + 3]  = (float)Col.A;
                Colors[j12 + 4]  = (float)Col.X;
                Colors[j12 + 5]  = (float)Col.Y;
                Colors[j12 + 6]  = (float)Col.Z;
                Colors[j12 + 7]  = (float)Col.A;
                Colors[j12 + 8]  = (float)Col.X;
                Colors[j12 + 9]  = (float)Col.Y;
                Colors[j12 + 10] = (float)Col.Z;
                Colors[j12 + 11] = (float)Col.A;
            }

            int DynCap = Gl.GL_STATIC_DRAW;

            Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, bufs[VertexIndex]);
            Gl.glBufferData(Gl.GL_ARRAY_BUFFER, (IntPtr)(Vertex.Length * sizeof(float)), Vertex, DynCap);
            Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, bufs[NormalIndex]);
            Gl.glBufferData(Gl.GL_ARRAY_BUFFER, (IntPtr)(Normals.Length * sizeof(float)), Normals, DynCap);
            Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, bufs[ColorIndex]);
            Gl.glBufferData(Gl.GL_ARRAY_BUFFER, (IntPtr)(Colors.Length * sizeof(float)), Colors, DynCap);
            Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, bufs[TextureIndex]);
            Gl.glBufferData(Gl.GL_ARRAY_BUFFER, (IntPtr)(TexCoords.Length * sizeof(float)), TexCoords, DynCap);
            Gl.glBindBuffer(Gl.GL_ELEMENT_ARRAY_BUFFER, bufs[PrimitiveIndex]);
            Gl.glBufferData(Gl.GL_ELEMENT_ARRAY_BUFFER, (IntPtr)(Elements.Length * sizeof(int)), Elements, DynCap);
            Utils.AssertGLError("build - bind VBO-s");

            /*     Colors = null;
             *   Vertex = null;
             *   Normals = null;
             *   Elements = null;
             *   TexCoords = null;*/
        }
Beispiel #40
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Bgra5551"/> struct.
 /// </summary>
 /// <param name="vector">
 /// The vector containing the components for the packed vector.
 /// </param>
 public Bgra5551(Vector4 vector)
 {
     this.PackedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
 }
Beispiel #41
0
 public void Write(Vector4 value) => this.WriteVector4(value);
Beispiel #42
0
 public void Colorizer(bool Enable, Vector4 MyColor)
 {
     Colorized    = Enable;
     this.MyColor = MyColor;
 }
 protected abstract void InitLight(MyLight light, Vector4 color, float radius, float falloff);
Beispiel #44
0
    private void RenderReflectionFor(Camera cam, Camera reflectCamera)
    {
        if (!reflectCamera)
        {
            return;
        }

        if (sharedMaterial && !sharedMaterial.HasProperty(reflectionSampler))
        {
            return;
        }

        reflectCamera.cullingMask = reflectionMask & ~(1 << LayerMask.NameToLayer("Water"));

        SaneCameraSettings(reflectCamera);

        reflectCamera.backgroundColor = clearColor;
        reflectCamera.clearFlags      = reflectSkybox ? CameraClearFlags.Skybox : CameraClearFlags.SolidColor;
        if (reflectSkybox)
        {
            if (cam.gameObject.GetComponent(typeof(Skybox)))
            {
                Skybox sb = (Skybox)reflectCamera.gameObject.GetComponent(typeof(Skybox));
                if (!sb)
                {
                    sb = (Skybox)reflectCamera.gameObject.AddComponent(typeof(Skybox));
                }
                sb.material = ((Skybox)cam.GetComponent(typeof(Skybox))).material;
            }
        }

        var oldCulling = GL.invertCulling;

        GL.invertCulling = !GL.invertCulling;

        Transform reflectiveSurface = transform; //waterHeight;

        Vector3 eulerA = cam.transform.eulerAngles;

        reflectCamera.transform.eulerAngles = new Vector3(-eulerA.x, eulerA.y, eulerA.z);
        reflectCamera.transform.position    = cam.transform.position;

        Vector3 pos = reflectiveSurface.transform.position;

        pos.y = reflectiveSurface.position.y;
        Vector3 normal          = reflectiveSurface.transform.up;
        float   d               = -Vector3.Dot(normal, pos) - clipPlaneOffset;
        Vector4 reflectionPlane = new Vector4(normal.x, normal.y, normal.z, d);

        Matrix4x4 reflection = Matrix4x4.zero;

        reflection = CalculateReflectionMatrix(reflection, reflectionPlane);
        oldpos     = cam.transform.position;
        Vector3 newpos = reflection.MultiplyPoint(oldpos);

        reflectCamera.worldToCameraMatrix = cam.worldToCameraMatrix * reflection;

        Vector4 clipPlane = CameraSpacePlane(reflectCamera, pos, normal, 1.0f);

        reflectCamera.projectionMatrix = cam.CalculateObliqueMatrix(clipPlane);

        reflectCamera.transform.position = newpos;
        Vector3 euler = cam.transform.eulerAngles;

        reflectCamera.transform.eulerAngles = new Vector3(-euler.x, euler.y, euler.z);

        reflectCamera.Render();

        GL.invertCulling = oldCulling;
    }
Beispiel #45
0
        public static void CrossProduct4D_Theory(Vector128 <float> left, Vector128 <float> right, Vector128 <float> third, Vector4 expected)
        {
            Vector128 <float> result = Vector.CrossProduct4D(left, right, third);

            Assert.True(AreEqual(expected, result), $"Expected {expected}, got {result}");
        }
        public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
        {
            var sinkComp = new MyResourceSinkComponent();

            sinkComp.Init(
                BlockDefinition.ResourceSinkGroup,
                BlockDefinition.RequiredPowerInput,
                () => (Enabled && IsFunctional) ? ResourceSink.MaxRequiredInput : 0f);
            sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged;
            ResourceSink = sinkComp;

            base.Init(objectBuilder, cubeGrid);
            this.IsLargeLight = cubeGrid.GridSizeEnum == MyCubeSize.Large;

            var     builder    = (MyObjectBuilder_LightingBlock)objectBuilder;
            MyModel lightModel = VRage.Game.Models.MyModels.GetModelOnlyDummies(BlockDefinition.Model);

            foreach (var pair in lightModel.Dummies)
            {
                if (!pair.Key.ToLower().Contains("light"))
                {
                    continue;
                }

                m_lightLocalPosition = pair.Value.Matrix.Translation;
                break;
            }

            Vector4 color = (builder.ColorAlpha == -1)
                ? LightColorDef
                : new Vector4(builder.ColorRed, builder.ColorGreen, builder.ColorBlue, builder.ColorAlpha);

            float radius          = RadiusBounds.Clamp((builder.Radius == -1f) ? RadiusBounds.Default : builder.Radius);
            float reflectorRadius = ReflectorRadiusBounds.Clamp((builder.ReflectorRadius == -1f) ? ReflectorRadiusBounds.Default : builder.ReflectorRadius);
            float falloff         = FalloffBounds.Clamp(builder.Falloff);

            m_blinkIntervalSeconds.Value = BlinkIntervalSecondsBounds.Clamp((builder.BlinkIntervalSeconds == -1f) ? BlinkIntervalSecondsBounds.Default : builder.BlinkIntervalSeconds);

            m_blinkLength.Value = BlinkLenghtBounds.Clamp((builder.BlinkLenght == -1f) ? BlinkLenghtBounds.Default : builder.BlinkLenght);

            m_blinkOffset.Value = BlinkOffsetBounds.Clamp((builder.BlinkOffset == -1f) ? BlinkOffsetBounds.Default : builder.BlinkOffset);

            m_intesity.Value = IntensityBounds.Clamp((builder.Intensity == -1f) ? IntensityBounds.Default : builder.Intensity);


            m_positionDirty = true;
            m_light         = MyLights.AddLight();
            InitLight(m_light, color, radius, falloff);

            m_light.ReflectorRange = reflectorRadius;
            m_light.Range          = radius;
            m_light.ReflectorOn    = false;
            m_light.LightOn        = false;
            m_light.GlareOn        = false;

            UpdateIntensity();
            UpdateLightPosition();

            NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME;
            Render.NeedsDrawFromParent = true;


            AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(ResourceSink, this));
            ResourceSink.Update();
            SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
            IsWorkingChanged += CubeBlock_OnWorkingChanged;
        }
Beispiel #47
0
	void Update ()
	{
		if (mAnim != null && mAnim.isPlaying) return;

		if (style != Style.None)
		{
			float adjustment = 1f;

			if (panelContainer != null)
			{
				if (panelContainer.clipping == UIDrawCall.Clipping.None)
				{
					// Panel has no clipping -- just use the screen's dimensions
					mRect.xMin = -Screen.width * 0.5f;
					mRect.yMin = -Screen.height * 0.5f;
					mRect.xMax = -mRect.xMin;
					mRect.yMax = -mRect.yMin;
				}
				else
				{
					// Panel has clipping -- use it as the rect
					Vector4 pos = panelContainer.clipRange;
					mRect.x = pos.x - (pos.z * 0.5f);
					mRect.y = pos.y - (pos.w * 0.5f);
					mRect.width = pos.z;
					mRect.height = pos.w;
				}
			}
			else if (widgetContainer != null)
			{
				// Widget is used -- use its bounds as the container's bounds
				Transform t = widgetContainer.cachedTransform;
				Vector3 ls = t.localScale;
				Vector3 lp = t.localPosition;

				Vector3 size = widgetContainer.relativeSize;
				Vector3 offset = widgetContainer.pivotOffset;
				offset.y -= 1f;

				offset.x *= (widgetContainer.relativeSize.x * ls.x);
				offset.y *= (widgetContainer.relativeSize.y * ls.y);

				mRect.x = lp.x + offset.x;
				mRect.y = lp.y + offset.y;

				mRect.width = size.x * ls.x;
				mRect.height = size.y * ls.y;
			}
			else if (uiCamera != null)
			{
				mRect = uiCamera.pixelRect;
				if (mRoot != null) adjustment = mRoot.pixelSizeAdjustment;
			}
			else return;

			float rectWidth = mRect.width;
			float rectHeight = mRect.height;

			if (adjustment != 1f && rectHeight > 1f)
			{
				float scale = mRoot.activeHeight / rectHeight;
				rectWidth *= scale;
				rectHeight *= scale;
			}

			Vector3 localScale = mTrans.localScale;

			if (style == Style.BasedOnHeight)
			{
				localScale.x = relativeSize.x * rectHeight;
				localScale.y = relativeSize.y * rectHeight;
			}
			else if (style == Style.FillKeepingRatio)
			{
				// Contributed by Dylan Ryan
				float screenRatio = rectWidth / rectHeight;
				float imageRatio = initialSize.x / initialSize.y;

				if (imageRatio < screenRatio)
				{
					// Fit horizontally
					float scale = rectWidth / initialSize.x;
					localScale.x = rectWidth;
					localScale.y = initialSize.y * scale;
				}
				else
				{
					// Fit vertically
					float scale = rectHeight / initialSize.y;
					localScale.x = initialSize.x * scale;
					localScale.y = rectHeight;
				}
			}
			else if (style == Style.FitInternalKeepingRatio)
			{
				// Contributed by Dylan Ryan
				float screenRatio = rectWidth / rectHeight;
				float imageRatio = initialSize.x / initialSize.y;

				if (imageRatio > screenRatio)
				{
					// Fit horizontally
					float scale = rectWidth / initialSize.x;
					localScale.x = rectWidth;
					localScale.y = initialSize.y * scale;
				}
				else
				{
					// Fit vertically
					float scale = rectHeight / initialSize.y;
					localScale.x = initialSize.x * scale;
					localScale.y = rectHeight;
				}
			}
			else
			{
				if (style == Style.Both || style == Style.Horizontal) localScale.x = relativeSize.x * rectWidth;
				if (style == Style.Both || style == Style.Vertical) localScale.y = relativeSize.y * rectHeight;
			}

			if (mTrans.localScale != localScale) mTrans.localScale = localScale;
			if (runOnlyOnce && Application.isPlaying) Destroy(this);
		}
	}
Beispiel #48
0
        private void ErodeHelper(Vector3 terrainScale, Rect domainRect, Vector2 texelSize, bool invertEffect, bool lowRes)
        {
            RenderTexture tmpRT = UnityEngine.RenderTexture.active;

            //this one is mandatory
            if (!inputTextures.ContainsKey("Height"))
            {
                throw (new Exception("No input heightfield specified!"));
            }

            #region Find Compute Kernels
            ComputeShader advectionCS  = GetComputeShader("Advection");
            ComputeShader projectionCS = GetComputeShader("Projection");
            ComputeShader diffusionCS  = GetComputeShader("Diffusion");
            ComputeShader utilityCS    = GetComputeShader("ImageUtility");
            ComputeShader aeolianCS    = GetComputeShader("Aeolian");
            ComputeShader thermalCS    = GetComputeShader("Thermal");

            int advectKernelIdx           = advectionCS.FindKernel("Advect");
            int divergenceKernelIdx       = projectionCS.FindKernel("Divergence");
            int gradientSubtractKernelIdx = projectionCS.FindKernel("GradientSubtract");
            int diffuseKernelIdx          = diffusionCS.FindKernel("Diffuse");
            int remapKernelIdx            = utilityCS.FindKernel("RemapValues");
            int addConstantIdx            = utilityCS.FindKernel("AddConstant");
            int applyDragKernelIdx        = aeolianCS.FindKernel("ApplyHeightfieldDrag");
            int erodeKernelIdx            = aeolianCS.FindKernel("WindSedimentErode");
            int thermalKernelIdx          = thermalCS.FindKernel("ThermalErosion");

            int[] numWorkGroups = { 8, 8, 1 };
            #endregion

            #region Calculate Domain Rect Size
            //figure out what size we need our render targets to be
            int xRes = (int)inputTextures["Height"].width;
            int yRes = (int)inputTextures["Height"].height;

            int rx = xRes - (numWorkGroups[0] * (xRes / numWorkGroups[0]));
            int ry = yRes - (numWorkGroups[1] * (yRes / numWorkGroups[1]));

            xRes += numWorkGroups[0] - rx;
            yRes += numWorkGroups[1] - ry;

            #endregion

            #region Create Render Textures
            RenderTexture heightmapRT     = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
            RenderTexture heightmapPrevRT = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
            RenderTexture collisionRT     = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
            RenderTexture sedimentPrevRT  = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);
            RenderTexture sedimentRT      = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);

            RenderTexture windVelRT     = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RGFloat, RenderTextureReadWrite.Linear);
            RenderTexture windVelPrevRT = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RGFloat, RenderTextureReadWrite.Linear);
            RenderTexture divergenceRT  = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);

            RenderTexture thermalSedimentRT = RenderTexture.GetTemporary(xRes, yRes, 0, RenderTextureFormat.RFloat, RenderTextureReadWrite.Linear);

            heightmapRT.enableRandomWrite       = true;
            heightmapPrevRT.enableRandomWrite   = true;
            collisionRT.enableRandomWrite       = true;
            sedimentRT.enableRandomWrite        = true;
            sedimentPrevRT.enableRandomWrite    = true;
            windVelRT.enableRandomWrite         = true;
            windVelPrevRT.enableRandomWrite     = true;
            divergenceRT.enableRandomWrite      = true;
            thermalSedimentRT.enableRandomWrite = true;
            #endregion


            #region Setup Input Textures
            //clear the render textures
            Graphics.Blit(Texture2D.blackTexture, sedimentRT);
            Graphics.Blit(Texture2D.blackTexture, collisionRT);
            Graphics.Blit(Texture2D.blackTexture, windVelRT);
            Graphics.Blit(Texture2D.blackTexture, windVelPrevRT);

            Graphics.Blit(inputTextures["Height"], heightmapPrevRT);
            Graphics.Blit(inputTextures["Height"], heightmapRT);
            #endregion

            //precompute some values on the CPU (these become uniform constants in the shader)
            float dx = (float)texelSize.x * m_SimulationScale.value;
            float dy = (float)texelSize.y * m_SimulationScale.value;

            float   dxy       = Mathf.Sqrt(dx * dx + dy * dy);
            float   gridScale = 0.5f * dx;
            Vector4 dxdy      = new Vector4(dx, dy, dxy, gridScale);

            advectionCS.SetFloat("dt", m_dt.value);
            advectionCS.SetFloat("velScale", m_AdvectionVelScale.value);
            advectionCS.SetVector("dxdy", dxdy);
            advectionCS.SetVector("terrainDim", new Vector4());
            advectionCS.SetVector("texDim", new Vector4((float)xRes, (float)yRes, 0.0f, 0.0f));

            diffusionCS.SetFloat("dt", m_dt.value);

            projectionCS.SetVector("dxdy", dxdy);

            aeolianCS.SetFloat("dt", m_dt.value);
            aeolianCS.SetFloat("SuspensionRate", m_SuspensionRate.value);
            aeolianCS.SetFloat("DepositionRate", m_DepositionRate.value);
            aeolianCS.SetFloat("SlopeFactor", m_SlopeFactor.value);
            aeolianCS.SetFloat("DragCoefficient", m_DragCoefficient.value);
            aeolianCS.SetFloat("ReflectionCoefficient", m_ReflectionCoefficient.value);
            aeolianCS.SetFloat("AbrasivenessCoefficient", m_AbrasivenessCoefficient.value * 1000.0f);
            aeolianCS.SetVector("texDim", new Vector4((float)xRes, (float)yRes, 0.0f, 0.0f));

            //use full tile res here?
            diffusionCS.SetVector("texDim", new Vector4((float)inputTextures["Height"].width, (float)inputTextures["Height"].height, 0.0f, 0.0f));

            #region Fluid Simulation Loop
            for (int i = 0; i < m_Iterations.value; i++)
            {
                #region Velocity Step

                utilityCS.SetTexture(addConstantIdx, "OutputTex", windVelPrevRT);
                utilityCS.SetVector("Constant", m_WindVel);
                utilityCS.Dispatch(addConstantIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                //Apply drag from heightfield
                aeolianCS.SetTexture(applyDragKernelIdx, "InHeightMap", heightmapPrevRT);
                aeolianCS.SetTexture(applyDragKernelIdx, "WindVel", windVelPrevRT);
                aeolianCS.SetTexture(applyDragKernelIdx, "OutWindVel", windVelRT);
                aeolianCS.Dispatch(applyDragKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                //Diffuse Velocity
                diffusionCS.SetFloat("diff", m_Viscosity.value);
                for (int j = 0; j < m_DiffuseSteps; j++)
                {
                    diffusionCS.SetTexture(diffuseKernelIdx, "InputTex", windVelRT);
                    diffusionCS.SetTexture(diffuseKernelIdx, "OutputTex", windVelPrevRT);

                    diffusionCS.Dispatch(diffuseKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);
                    Graphics.Blit(windVelPrevRT, windVelRT);
                }

                //Project Velocity
                for (int j = 0; j < m_ProjectionSteps; j++)
                {
                    projectionCS.SetTexture(divergenceKernelIdx, "VelocityTex2D", windVelRT);
                    projectionCS.SetTexture(divergenceKernelIdx, "DivergenceTex2D", divergenceRT);
                    projectionCS.Dispatch(divergenceKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                    projectionCS.SetTexture(gradientSubtractKernelIdx, "PressureTex2D", divergenceRT);
                    projectionCS.SetTexture(gradientSubtractKernelIdx, "VelocityTex2D", windVelRT);
                    projectionCS.SetTexture(gradientSubtractKernelIdx, "VelocityOutTex2D", windVelPrevRT);
                    projectionCS.Dispatch(gradientSubtractKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                    Graphics.Blit(windVelPrevRT, windVelRT);
                }

                //Advect velocity along previous iteration's velocity field
                advectionCS.SetTexture(advectKernelIdx, "InputTex", windVelRT);
                advectionCS.SetTexture(advectKernelIdx, "OutputTex", windVelPrevRT);
                advectionCS.SetTexture(advectKernelIdx, "VelocityTex", windVelRT);

                advectionCS.Dispatch(advectKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                Graphics.Blit(windVelPrevRT, windVelRT);
                #endregion

                #region Density Step
                //Diffuse Sediment
                diffusionCS.SetFloat("diff", m_DiffusionRate.value);
                for (int j = 0; j < m_DiffuseSteps; j++)
                {
                    diffusionCS.SetTexture(diffuseKernelIdx, "InputTex", sedimentRT);
                    diffusionCS.SetTexture(diffuseKernelIdx, "OutputTex", sedimentPrevRT);

                    diffusionCS.Dispatch(diffuseKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);
                    Graphics.Blit(sedimentPrevRT, sedimentRT);
                }

                //Advect Sediment
                advectionCS.SetTexture(advectKernelIdx, "InputTexFloat", sedimentRT);
                advectionCS.SetTexture(advectKernelIdx, "OutputTexFloat", sedimentPrevRT);
                advectionCS.SetTexture(advectKernelIdx, "VelocityTex", windVelRT);

                advectionCS.Dispatch(advectKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                #endregion


                #region Erosion Step

                // Erode Sediment (pick sediment up off the heightmap and store in sediment RT)
                aeolianCS.SetTexture(erodeKernelIdx, "InHeightMap", heightmapPrevRT);
                aeolianCS.SetTexture(erodeKernelIdx, "InSediment", sedimentPrevRT);
                aeolianCS.SetTexture(erodeKernelIdx, "WindVel", windVelRT);
                aeolianCS.SetTexture(erodeKernelIdx, "OutSediment", sedimentRT);
                aeolianCS.SetTexture(erodeKernelIdx, "OutHeightMap", heightmapRT);
                aeolianCS.Dispatch(erodeKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);

                #endregion

                #region Thermal / Diffusion
                thermalCS.SetFloat("dt", m_ThermalTimeDelta.value * m_dt.value);
                thermalCS.SetVector("dxdy", dxdy);
                thermalCS.SetVector("terrainDim", new Vector4(terrainScale.x, terrainScale.y, terrainScale.z));
                thermalCS.SetVector("texDim", new Vector4((float)xRes, (float)yRes, 0.0f, 0.0f));

                thermalCS.SetTexture(thermalKernelIdx, "TerrainHeightPrev", heightmapPrevRT);
                thermalCS.SetTexture(thermalKernelIdx, "TerrainHeight", heightmapRT);
                thermalCS.SetTexture(thermalKernelIdx, "Sediment", thermalSedimentRT);
                thermalCS.SetTexture(thermalKernelIdx, "ReposeMask", collisionRT); //TODO
                thermalCS.SetTexture(thermalKernelIdx, "Collision", collisionRT);
                thermalCS.SetTexture(thermalKernelIdx, "Hardness", collisionRT);   //TODO

                Graphics.Blit(heightmapRT, heightmapPrevRT);
                for (int j = 0; j < m_ThermalIterations; j++)
                {
                    Vector2 m = new Vector2(Mathf.Tan(m_AngleOfRepose * Mathf.Deg2Rad), Mathf.Tan(m_AngleOfRepose * Mathf.Deg2Rad));
                    thermalCS.SetVector("angleOfRepose", new Vector4(m.x, m.y, 0.0f, 0.0f));

                    thermalCS.Dispatch(thermalKernelIdx, xRes / numWorkGroups[0], yRes / numWorkGroups[1], numWorkGroups[2]);
                    Graphics.Blit(heightmapRT, heightmapPrevRT);
                }
                #endregion

                //swap buffers for next iteration
                //Graphics.Blit(heightmapRT, heightmapPrevRT);
                Graphics.Blit(sedimentRT, sedimentPrevRT);
            }
            #endregion

            Graphics.Blit(heightmapRT, outputTextures["Height"]);
            Graphics.Blit(windVelRT, outputTextures["Wind Velocity"]);
            Graphics.Blit(divergenceRT, outputTextures["Divergence"]);
            Graphics.Blit(thermalSedimentRT, outputTextures["Thermal Sediment"]);
            Graphics.Blit(sedimentRT, outputTextures["Sediment"]);

            RenderTexture.ReleaseTemporary(heightmapRT);
            RenderTexture.ReleaseTemporary(heightmapPrevRT);
            RenderTexture.ReleaseTemporary(collisionRT);
            RenderTexture.ReleaseTemporary(sedimentRT);
            RenderTexture.ReleaseTemporary(sedimentPrevRT);
            RenderTexture.ReleaseTemporary(windVelRT);
            RenderTexture.ReleaseTemporary(windVelPrevRT);
            RenderTexture.ReleaseTemporary(divergenceRT);
            RenderTexture.ReleaseTemporary(thermalSedimentRT);

            UnityEngine.RenderTexture.active = tmpRT;
        }
Beispiel #49
0
        private void CreateVertexBuffer(Device device)
        {
            _vertices = new VertexDefinition.PositionTextureColor[_numberOfLetters * 4];
            int   letterIndex = 0;
            Color color       = BaseColor;
            int   lineHeight  = Font.Characters.First().Value.height;
            float spaceSize   = SpaceSize;

            float positionY = Padding.Top;

            if (VerticalAlignment == VerticalAlignment.Bottom)
            {
                positionY = Size.Y - (lineHeight * Lines.Count + LineSpacing * (Lines.Count - 1)) - Padding.Bottom;
            }
            if (VerticalAlignment == VerticalAlignment.Middle)
            {
                positionY = Padding.Top + (float)(Size.Y - Padding.Bottom - Padding.Top - (lineHeight * Lines.Count + LineSpacing * (Lines.Count - 1))) / 2;
            }

            for (int i = 0; i < Lines.Count; i++)
            {
                TextLine line = Lines[i];
                line.Width -= SpaceSize + 1; //Remove last space and pixel padding after last character
                float positionX = Padding.Left;
                if (HorizontalAlignment == HorizontalAlignment.Right)
                {
                    positionX = Size.X - line.Width - Padding.Right;
                }
                if (HorizontalAlignment == HorizontalAlignment.Center)
                {
                    positionX = Padding.Left + (float)(Size.X - Padding.Left - Padding.Right - line.Width) / 2;
                }
                if (HorizontalAlignment == HorizontalAlignment.Justify && line.WordWrapped)
                {
                    spaceSize = SpaceSize + (float)(Size.X - Padding.Left - Padding.Right - line.Width) / (line.WordCount - 1);
                }
                for (int j = 0; j < line.Words.Count; j++)
                {
                    string word = line.Words[j];
                    for (int k = 0; k < word.Length; k++)
                    {
                        char letter = word[k];
                        if (letter == '[')
                        {
                            if (word[k + 1] != '[')
                            {
                                string token = word.Substring(k + 1, word.IndexOf(']', k + 1) - (k + 1));
                                if (token == "-")
                                {
                                    color = BaseColor;
                                }
                                else if (!ColorParser.TryParse(token, out color))
                                {
                                    throw new InvalidOperationException("Unexpected token : " + token);
                                }
                                k = word.IndexOf(']', k + 1);
                                continue;
                            }
                            k++;
                        }
                        Vector4        colorAsVector = color.ToVector4();
                        Font.Character c             = Font.Characters[letter];
                        _vertices[letterIndex * 4] = new VertexDefinition.PositionTextureColor {
                            position = new Vector3(positionX, positionY, 0.0f), texture = new Vector2(c.uLeft, c.vTop), color = colorAsVector
                        };                                                                                                                                                                                            //Top left
                        _vertices[letterIndex * 4 + 1] = new VertexDefinition.PositionTextureColor {
                            position = new Vector3(positionX + c.width, positionY + c.height, 0.0f), texture = new Vector2(c.uRight, c.vBottom), color = colorAsVector
                        };                                                                                                                                                                                                                         //Right bottom
                        _vertices[letterIndex * 4 + 2] = new VertexDefinition.PositionTextureColor {
                            position = new Vector3(positionX, positionY + c.height, 0.0f), texture = new Vector2(c.uLeft, c.vBottom), color = colorAsVector
                        };                                                                                                                                                                                                              //Left bottom
                        _vertices[letterIndex * 4 + 3] = new VertexDefinition.PositionTextureColor {
                            position = new Vector3(positionX + c.width, positionY, 0.0f), texture = new Vector2(c.uRight, c.vTop), color = colorAsVector
                        };                                                                                                                                                                                                           //Top right
                        positionX += c.width + 1;
                        letterIndex++;
                    }
                    positionX += spaceSize;
                }
                positionY += lineHeight + LineSpacing;
            }
            if (_vertexBuffer != null)
            {
                _vertexBuffer.Dispose();
            }
            _vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, _vertices);
            UsedSize      = new Vector2I(Lines.Max(l => l.Width) + Padding.Left + Padding.Right,
                                         (lineHeight * Lines.Count + LineSpacing * (Lines.Count - 1)) + Padding.Bottom + Padding.Top);
        }
Beispiel #50
0
        protected override void Init(MyObjectBuilder_DefinitionBase builder)
        {
            base.Init(builder);

            var ob = builder as MyObjectBuilder_HandItemDefinition;

            MyDebug.AssertDebug(ob != null);

            Id = builder.Id;

            LeftHand             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.LeftHandOrientation));
            LeftHand.Translation = ob.LeftHandPosition;

            RightHand             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.RightHandOrientation));
            RightHand.Translation = ob.RightHandPosition;

            ItemLocation             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemOrientation));
            ItemLocation.Translation = ob.ItemPosition;

            ItemWalkingLocation             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemWalkingOrientation));
            ItemWalkingLocation.Translation = ob.ItemWalkingPosition;

            BlendTime = ob.BlendTime;

            XAmplitudeOffset = ob.XAmplitudeOffset;
            YAmplitudeOffset = ob.YAmplitudeOffset;
            ZAmplitudeOffset = ob.ZAmplitudeOffset;

            XAmplitudeScale = ob.XAmplitudeScale;
            YAmplitudeScale = ob.YAmplitudeScale;
            ZAmplitudeScale = ob.ZAmplitudeScale;

            RunMultiplier = ob.RunMultiplier;

            ItemLocation3rd             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemOrientation3rd));
            ItemLocation3rd.Translation = ob.ItemPosition3rd;

            ItemWalkingLocation3rd             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemWalkingOrientation3rd));
            ItemWalkingLocation3rd.Translation = ob.ItemWalkingPosition3rd;

            AmplitudeMultiplier3rd = ob.AmplitudeMultiplier3rd;

            SimulateLeftHand  = ob.SimulateLeftHand;
            SimulateRightHand = ob.SimulateRightHand;

            FingersAnimation = MyDefinitionManager.Static.GetAnimationDefinitionCompatibility(ob.FingersAnimation);

            ItemShootLocation                = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemShootOrientation));
            ItemShootLocation.Translation    = ob.ItemShootPosition;
            ItemShootLocation3rd             = Matrix.CreateFromQuaternion(Quaternion.Normalize(ob.ItemShootOrientation3rd));
            ItemShootLocation3rd.Translation = ob.ItemShootPosition3rd;
            ShootBlend = ob.ShootBlend;

            MuzzlePosition = ob.MuzzlePosition;

            ShootScatter   = ob.ShootScatter;
            ScatterSpeed   = ob.ScatterSpeed;
            PhysicalItemId = ob.PhysicalItemId;

            LightColor          = ob.LightColor;
            LightFalloff        = ob.LightFalloff;
            LightRadius         = ob.LightRadius;
            LightGlareSize      = ob.LightGlareSize;
            LightIntensityLower = ob.LightIntensityLower;
            LightIntensityUpper = ob.LightIntensityUpper;
            ShakeAmountTarget   = ob.ShakeAmountTarget;
            ShakeAmountNoTarget = ob.ShakeAmountNoTarget;
        }
Beispiel #51
0
 public MarkupStyleMesh()
 {
     Scale = new Vector4(0.5f / MeshHalfWidth, 0.5f / MeshHalfLength, 1f, 1f);
 }
Beispiel #52
0
        private Mesh CreateStarfieldMesh()
        {
            const int numberOfStars = 9110;

            var binaryDataFile = Resources.Load("Binary/Stars", typeof(TextAsset)) as TextAsset;

            if (binaryDataFile == null)
            {
                Debug.Log("Starfield: Binary data file reading error!");
                return(null);
            }

            var starsCIs = new List <CombineInstance>();

            using (var reader = new BinaryReader(new MemoryStream(binaryDataFile.bytes)))
            {
                for (int i = 0; i < numberOfStars - 1; i++)
                {
                    var star     = new StarfieldStar();
                    var starSize = StarsDistance / 100 * StarsScale;

                    // NOTE : Swap Z and Y...
                    star.Position = new Vector3(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
                    star.Color    = new Vector4(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), 0);

                    star.Position = Vector3.Scale(star.Position, new Vector3(-1.0f, 1.0f, -1.0f));
                    star.Color.w  = new Vector3(star.Color.x, star.Color.y, star.Color.z).magnitude;

                    if (star.Color.w > 5.7f)
                    {
                        star.Color = Vector4.Normalize(star.Color) * 0.5f;
                    }

                    var ci = new CombineInstance
                    {
                        mesh      = MeshFactory.MakeBillboardQuad(starSize),
                        transform = MatrixHelper.BillboardMatrix(star.Position * StarsDistance)
                    };

                    ci.mesh.colors = new Color[] { star.Color, star.Color, star.Color, star.Color };

                    starsCIs.Add(ci);
                }
            }

            var mesh = new Mesh();

            mesh.CombineMeshes(starsCIs.ToArray());
            mesh.name      = string.Format("StarfieldMesh_({0})", Random.Range(float.MinValue, float.MaxValue));
            mesh.bounds    = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
            mesh.hideFlags = HideFlags.DontSave;

            #region Cleanup

            foreach (var ci in starsCIs)
            {
                Helper.Destroy(ci.mesh);
            }

            starsCIs.Clear();

            GC.Collect();

            #endregion

            return(mesh);
        }
Beispiel #53
0
            override public void Draw(Rect input, out Vector2[] output)
            {
                output = new Vector2[1];
                if (!target.target.compiler || !target.target.compiler.material)
                {
                    return;
                }

                for (int i = 0; i < output.Length; i++)
                {
                    output[i] = Vector2.zero;
                }
                LAST_GROUP_R = new Rect(input.x, input.y, input.width, target.MENU_CURRENT_HEIGHT());
                GUI.BeginGroup(LAST_GROUP_R);
                var r  = new Rect(0, 0, BOTTOM_W * 1.333333f, 0);
                var og = GUI.enabled;



                // r.y += 10;


                GUI.enabled = target.DRAW_TOGGLE(r, "ZDepth Colorize", "USE_lerped_post", true, out tV); r.y += 31;
                target.DRAW_TOGGLE(r, "Use Deep Z Depth", "lerped_post_USE_depthZ", GUI.enabled, out tV); r.y += 31;

                r = target.DRAW_SLIDER(r, "Offset", "lerped_post_offset", -80, 80, GUI.enabled); r.y += r.height;
                r = target.DRAW_SLIDER(r, "Fallof", "lerped_post_offset_falloff", 0, 80, GUI.enabled); r.y += r.height;
                target.DRAW_TOGGLE(r, "Debug Offset", "lerped_post_Debug", GUI.enabled, out tV); r.y += 31;
                var oe = GUI.enabled;
                var c1 = target.DRAW_TOGGLE(r, "Color A", "USE_lerped_post_Color_1", oe, out tV) && oe; r.y += 31;

                GUI.enabled = c1;
                r.height    = FastWaterModel20ControllerEditor.H;
                target.pop_zcolorize1.DrawPop(null, r); r.y += r.height;
                r = target.DRAW_COLOR(r, null, "lerped_post_color1", GUI.enabled, out tV, false); r.y += r.height;

                var c2 = target.DRAW_TOGGLE(r, "Color B", "USE_lerped_post_Color_2", oe, out tV) && oe; r.y += 31;

                GUI.enabled = c2;
                r.height    = FastWaterModel20ControllerEditor.H;
                target.pop_zcolorize2.DrawPop(null, r); r.y += r.height;
                r = target.DRAW_COLOR(r, null, "lerped_post_color2", GUI.enabled, out tV, false); r.y += r.height;

                GUI.enabled = true;

                r.y += FastWaterModel20ControllerEditor.H;


                var ent = target.DRAW_TOGGLE(r, "Texture Colorize", "POST_TEXTURE_TINT", true, out tV); r.y += 31;

                GUI.enabled = ent;


                /*  var foam = false;
                 * if (target.MODE_ULTRA_FAST)foam =  target.DRAW_TOGGLE(r, "Use Foam Texture", "POST_FOAM_TEXTURE", GUI.enabled, out tV) && GUI.enabled; r.y += 31;
                 * var own =  target.DRAW_TOGGLE(r, "Use Own Texture", "POST_OWN_TEXTURE", !foam && GUI.enabled, out tV) && !foam && GUI.enabled; r.y += 31;
                 * GUI.enabled = ent;
                 * if (foam) { r = target.DRAW_BG_TEXTURE(r, null, "_ShoreWavesGrad", foam, out tV, null); r.y += r.height; }
                 * else if (own) { r = target.DRAW_BG_TEXTURE(r, null, "_MM_Texture", own, out tV, null); r.y += r.height; }
                 * else { r = DRAW_GRAPHIC(r, 40, target.target.compiler.GetTexture(FIELDS._MainTex) as Texture2D, GUI.enabled, null); r.y += r.height; }*/


                string[]  texture          = new[] { "_MainTex", "_UF_NMASK_Texture", "_ShoreWavesGrad", "_MM_Texture" };
                POP_CLASS texture_SWITCHER = target.pop_postTExtureSwitcher;
                POP_CLASS pop_channel      = target.pop_postTextureChannel;
                bool      enable           = GUI.enabled;

                //////////////////////////////
                r = target.DrawTextureWIthChannelAndSwitcher(r, GUI.enabled, texture, texture_SWITCHER, pop_channel);



                /*r.height = FastWaterModel20ControllerEditor.H;
                 * target.pop_mmchannel.DrawPop(null, r); r.y += r.height;*/
                r = target.DRAW_VECTOR(r, "Tile X/Y", "_MM_Tile", 0, 10000, GUI.enabled, div: 100); r.y += r.height;
                r = target.DRAW_VECTOR(r, "Offset X/Y", "_MM_offset", 0, 10000, GUI.enabled, div: 100); r.y += r.height;

                r.height = FastWaterModel20ControllerEditor.H;
                target.pop_mmcolorize.DrawPop(null, r); r.y += r.height;
                if (target.pop_mmcolorize.VALUE == 2)
                {
                    r = target.DRAW_SLIDER(r, "Multy Offset", "_MM_MultyOffset", 0, 1, GUI.enabled); r.y += r.height;
                }
                r = target.DRAW_COLOR(r, "Color", "_MM_Color", GUI.enabled, out tV, false); r.y += r.height;


                GUI.enabled = true;

                /*  GUI.enabled = true;
                 * var use_sg = GUI.enabled = target.DRAW_TOGGLE(r, "Surface Gradient", "USE_SURFACE_GRADS", GUI.enabled, out tV); r.y += 31;
                 * r = target.DRAW_SLIDER(r, "Offset Top", "_WaveGradTopOffset", 0, 100, GUI.enabled); r.y += r.height;
                 * target.DRAW_TOGGLE(r, "Debug Gradient", "DEBUG_TOP_GRAD", use_sg, out tV); r.y += 31;
                 * r = target.DRAW_COLOR(r, null, "_WaveGrad0", use_sg, out tV, false); r.y += r.height;
                 * r = target.DRAW_COLOR(r, null, "_WaveGrad1", use_sg, out tV, false); r.y += r.height;
                 * r = target.DRAW_COLOR(r, null, "_WaveGrad2", use_sg, out tV, false); r.y += r.height;
                 * r = target.DRAW_SLIDER(r, "Offset Mid", "_WaveGradMidOffset", 0, 1, GUI.enabled); r.y += r.height;
                 *
                 */

                GUI.enabled = true;



                r.y += 10;
                r.x += r.width + 14;
                r.y  = 0;

                GUI.enabled = og;
                GUI.enabled = target.DRAW_TOGGLE(r, "images_postrize", "POSTRIZE", true, out tV); r.y += 31;
                r           = target.DRAW_SLIDER(r, "Posterize", "POSTRIZE_Colors", 1, 24, GUI.enabled); r.y += r.height;
                GUI.enabled = og;


                r.y += FastWaterModel20ControllerEditor.H;



                GUI.enabled = target.DRAW_TOGGLE(r, "Convert Colors", "USE_OUTPUT_GRADIENT", true, out tV); r.y += 31;
                target.DRAW_TOGGLE(r, "images_cc", null, GUI.enabled, out tV); r.y += 31;
                r.height = FastWaterModel20ControllerEditor.H;
                //EditorGUI.HelpBox( r, "Utils (RGB:y>0.5)", MessageType.None ); r.y += r.height;
                r = target.DRAW_BG_TEXTURE(r, "Gradient Texture", "_GradTexture", GUI.enabled, out tV, null); r.y += r.height;
                // r = DRAW_GRAPHIC( r, 40, target.target.material.GetTexture( FIELDS._Utility ) as Texture2D, GUI.enabled, new Color( 1, 1, 1, 1 ), YUP: 0.5f ); r.y += r.height;

                r.height = FastWaterModel20ControllerEditor.H;
                target.pop_gradientoutput.DrawPop(null, r); r.y           += r.height;
                EditorGUI.HelpBox(r, "Blend Mode", MessageType.None); r.y += r.height;
                target.pop_outputblend.DrawPop(null, r); r.y += r.height;
                r = target.DRAW_SLIDER(r, "Blend", "_OutGradBlend", 0, 1, GUI.enabled); r.y += r.height;
                if (target.pop_outputblend.VALUE != 2)
                {
                    if (target.__pop_depth != null && target.__pop_depth.VALUE == 0)
                    {
                        r.height = FastWaterModel20ControllerEditor.H * 3;
                        EditorGUI.HelpBox(r, "Request ZDepth", MessageType.Error); r.y += r.height;
                    }
                    r = target.DRAW_SLIDER(r, "ZDepth Affect", "_OutGradZ", 1, 100, GUI.enabled); r.y += r.height;
                }

                if (target.pop_outputblend.VALUE != 0)
                {
                    var fhl = target.DRAW_TOGGLE(r, "Fix Highlights", "FIX_HL", GUI.enabled, out tV) & GUI.enabled; r.y += 31;
                    if (fhl)
                    {
                        r = target.DRAW_SLIDER(r, "Clamp Value", "_FixHLClamp", 0.1f, 1, fhl); r.y += r.height;
                    }
                }


                /*GUI.enabled = target.DRAW_TOGGLE(r, "Additional Shadows", "USE_OUTPUT_SHADOWS", GUI.enabled, out tV); r.y += 31;
                 * if (GUI.enabled) r = target.DRAW_SLIDER(r, "Amount", "_OutShadowsAmount", 0, 2, GUI.enabled); r.y += r.height;*/

                GUI.enabled = og;



                r.y += FastWaterModel20ControllerEditor.H;

                GUI.enabled = target.DRAW_TOGGLE(r, "images_rim", "RIM", true, out tV); r.y += 31;
                r           = target.DRAW_BG_TEXTURE(r, "Gradient", "_RimGradient", GUI.enabled, out tV, null); r.y += r.height;
                r           = target.DRAW_SLIDER_WITHTOGGLE(r, "Blend", "_RIM_BLEND", 0, 1, GUI.enabled, "USE_RIM_BLEND"); r.y += r.height;
                r.height    = FastWaterModel20ControllerEditor.H * 2;
                if (target.target.compiler.IsKeywordEnabled("SKIP_FRESNEL_CALCULATION"))
                {
                    EditorGUI.HelpBox(r, "Fresnel Disabled", MessageType.None);
                }
                else
                {
                    EditorGUI.HelpBox(r, "Using Fresnel Channel", MessageType.None);
                }
                r.y += r.height;
                r    = target.DRAW_SLIDER(r, "Rim Blend", "RIM_Plus", 0, 1, GUI.enabled, div: 100); r.y += r.height;
                r    = target.DRAW_SLIDER(r, "Rim Pow", "RIM_Minus", 0, 256, GUI.enabled); r.y += r.height;
                //  target.DRAW_TOGGLE(r, "Inverse", "RIM_INVERSE", GUI.enabled, out tV); r.y += 31;
                target.DRAW_TOGGLE(r, "Shore Affect", "RIM_SCHORE_SKIP", GUI.enabled, out tV); r.y += 31;


                target.DRAW_TOGGLE(r, "Rim Debug", "RIM_DEBUG", GUI.enabled, out tV); r.y += 31;

                GUI.enabled = true;

                r.y += 10;
                r.x += r.width + 14;
                r.y  = 0;

                GUI.enabled = target.target.compiler.IsKeywordEnabled("USE_SHADOWS") && target.IS_OPAQUE;
                target.DRAW_TOGGLE(r, "Shadows", null, GUI.enabled, out tV); r.y += 31;
                r           = target.DRAW_SLIDER(r, "Shadows Amount", "_ShadorAmount", 0, 1, GUI.enabled); r.y += r.height;
                GUI.enabled = true;

                r.y     += FastWaterModel20ControllerEditor.H;
                r.height = FastWaterModel20ControllerEditor.H * 3;
                EditorGUI.HelpBox(r, "Is case, if you don't use fullscreen effects, you may apply LUT gradient here", MessageType.None); r.y += r.height;
                GUI.enabled = target.DRAW_TOGGLE(r, "Use LUT's", "USE_LUT", GUI.enabled, out tV); r.y += 31;
                r           = target.DRAW_BG_TEXTURE(r, null, "_Lut2D", GUI.enabled, out tV, null); r.y += r.height;
                if (GUI.enabled)
                {
                    var t = target.target.compiler.GetTexture("_Lut2D");
                    if (!t)
                    {
                        t = ASSIGN_LUT();
                        if (t)
                        {
                            target.target.Undo();
                            target.target.compiler.SetTexture("_Lut2D", t);
                            target.target.SetDirty();
                        }
                    }
                    if (t)
                    {
                        var tp = new Vector4(1f / t.width, 1f / t.height, t.height - 1f, 0);
                        if (tp != target.target.compiler.GetVector("_Lut2D_params"))
                        {
                            target.target.Undo();
                            target.target.compiler.SetVector("_Lut2D_params", tp);
                            target.target.SetDirty();
                        }
                    }
                }


                r = target.DRAW_SLIDER(r, "Amount", "_LutAmount", 0, 1, GUI.enabled); r.y += r.height;
                target.DRAW_TOGGLE(r, "HQ Mode", "LUT_HQ_MODE", GUI.enabled, out tV); r.y           += 31;
                target.DRAW_TOGGLE(r, "Fix Overexposure", "FIX_OVEREXPO", GUI.enabled, out tV); r.y += 31;
                r.height = FastWaterModel20ControllerEditor.H * 3;
                EditorGUI.HelpBox(r, "Enable Fix if there're wrong colors near the overexposured pixels", MessageType.None);



                GUI.enabled  = og;
                LAST_GROUP_R = Rect.zero;
                GUI.EndGroup();
            }
Beispiel #54
0
        public void GetData(int index, out float positionX, out float positionY, out float positionZ, Vector4 color)
        {
            var modelInfo = _ModelInfoList[index];

            positionX = modelInfo.position.X;
            positionY = modelInfo.position.Y;
            positionZ = modelInfo.position.Z;
            color     = modelInfo.color;
        }
Beispiel #55
0
 /// <summary>
 /// Sets the packed vector from a Vector4.
 /// </summary>
 /// <param name="vector">Vector containing the components.</param>
 void IPackedVector.PackFromVector4(Vector4 vector)
 {
     _packedValue = (UInt16)((((int)(vector.X * 31.0f) & 0x1F) << 11) |
                             (((int)(vector.Y * 63.0f) & 0x3F) << 5) |
                             ((int)(vector.Z * 31.0f) & 0x1F));
 }
Beispiel #56
0
        public void FitViewports()
        {
            //TODO: this doesn't work right in every circumstance

            foreach (GLViewport v in _viewports)
            {
                Vector4    p = v.Percentages;
                GLViewport x = null, y = null, z = null, w = null;
                Vector4    diff = new Vector4(float.MaxValue);
                foreach (GLViewport v2 in _viewports)
                {
                    if (v2 == v)
                    {
                        continue;
                    }

                    float diff2 = Math.Abs(p._x - v2.Percentages._x);
                    if (diff2 <= diff._x)
                    {
                        x       = v2;
                        diff._x = diff2;
                    }
                    diff2 = Math.Abs(p._y - v2.Percentages._y);
                    if (diff2 <= diff._y)
                    {
                        y       = v2;
                        diff._y = diff2;
                    }
                    diff2 = Math.Abs(p._z - v2.Percentages._z);
                    if (diff2 <= diff._z)
                    {
                        z       = v2;
                        diff._z = diff2;
                    }
                    diff2 = Math.Abs(p._w - v2.Percentages._w);
                    if (diff2 <= diff._w)
                    {
                        w       = v2;
                        diff._w = diff2;
                    }
                }
                Vector4 average = new Vector4(0.0f, 0.0f, 1.0f, 1.0f);
                if (diff._x > 0.0f && x != null)
                {
                    average._x = (v.Percentages._x + x.Percentages._x) / 2.0f;
                    x.SetXPercentage(average._x);
                }
                if (diff._y > 0.0f && y != null)
                {
                    average._y = (v.Percentages._y + y.Percentages._y) / 2.0f;
                    y.SetYPercentage(average._y);
                }
                if (diff._z > 0.0f && z != null)
                {
                    average._z = (v.Percentages._z + z.Percentages._z) / 2.0f;
                    z.SetZPercentage(average._z);
                }
                if (diff._w > 0.0f && w != null)
                {
                    average._w = (v.Percentages._w + w.Percentages._w) / 2.0f;
                    w.SetWPercentage(average._w);
                }
                v.SetPercentages(average);
            }
        }
Beispiel #57
0
 /// <summary>
 /// Calculates the dot product of the specified vector and plane.
 /// </summary>
 /// <param name="left">The source plane.</param>
 /// <param name="right">The source vector.</param>
 /// <param name="result">When the method completes, contains the dot product of the specified plane and vector.</param>
 public static void Dot(ref Plane left, ref Vector4 right, out float result)
 {
     result = (left.Normal.X * right.X) + (left.Normal.Y * right.Y) + (left.Normal.Z * right.Z) + (left.D * right.W);
 }
Beispiel #58
0
 	public static Mesh Combine (MeshInstance[] combines)
 	{
 		int vertexCount = 0;
 		int triangleCount = 0;
  
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 			{
 				vertexCount += combine.mesh.vertexCount;						
 			}
 		}
  
 		// Precomputed how many triangles we need instead
  
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 			{
 				triangleCount += combine.mesh.GetTriangles(combine.subMeshIndex).Length;
 			}
 		}
  
 		Vector3[] vertices = new Vector3[vertexCount] ;
 		Vector3[] normals = new Vector3[vertexCount] ;
 		Vector4[] tangents = new Vector4[vertexCount] ;
 		Vector2[] uv = new Vector2[vertexCount];
 		Vector2[] uv1 = new Vector2[vertexCount];		
  
 		int offset;
  
 		offset=0;
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 				Copy(combine.mesh.vertexCount, combine.mesh.vertices, vertices, ref offset, combine.transform);			
 		}		
  
 		offset=0;
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 			{
 				Matrix4x4 invTranspose = combine.transform;
 				invTranspose = invTranspose.inverse.transpose;
 				CopyNormal(combine.mesh.vertexCount, combine.mesh.normals, normals, ref offset, invTranspose);
 			}
  
 		}
 		offset=0;
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 			{
 				Matrix4x4 invTranspose = combine.transform;
 				invTranspose = invTranspose.inverse.transpose;
 				CopyTangents(combine.mesh.vertexCount, combine.mesh.tangents, tangents, ref offset, invTranspose);
 			}
  
 		}
 		offset=0;
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 				Copy(combine.mesh.vertexCount, combine.mesh.uv, uv, ref offset);
 		}
  
 		offset=0;
 		foreach( MeshInstance combine in combines )
 		{
 			if (combine.mesh)
 				Copy(combine.mesh.vertexCount, combine.mesh.uv1, uv1, ref offset);
 		}
  
 		int triangleOffset=0;
 		int vertexOffset=0;
  
 		int j=0;
  
 		Mesh mesh = new Mesh();
 		mesh.vertices = vertices;
 		mesh.normals = normals;
 		mesh.uv = uv;
 		mesh.uv1 = uv1;
 		mesh.tangents = tangents;
  
 		//Setting SubMeshes
 		mesh.subMeshCount = combines.Length;
  
 		foreach( MeshInstance combine in combines )
 		{		
 			int[]  inputtriangles = combine.mesh.GetTriangles(combine.subMeshIndex);
 			int[] trianglesx = new int[inputtriangles.Length];
 			for (int i=0;i<inputtriangles.Length;i++)
 			{
 				//triangles[i+triangleOffset] = inputtriangles[i] + vertexOffset;
 				trianglesx[i] = inputtriangles[i] + vertexOffset;						
 			}
 			triangleOffset += inputtriangles.Length;
 			mesh.SetTriangles(trianglesx,j++);
  
 			vertexOffset += combine.mesh.vertexCount;			
 		}
  
 		mesh.name = "Combined Mesh";
  
 		return mesh;
 	}
Beispiel #59
0
        private void DrawOnTexture(RenderTexture rt, Material mat, int pass, List <Vector4> worldPoints, GStylizedTerrain t)
        {
            Vector4        worldOffset      = new Vector4(0, HeightOffset, 0, 0);
            List <Vector4> normalizedPoints = new List <Vector4>();

            for (int i = 0; i < worldPoints.Count; ++i)
            {
                Vector3 v = t.WorldPointToNormalized(worldPoints[i] + worldOffset);
                normalizedPoints.Add(new Vector4(Mathf.Clamp01(v.x), Mathf.Clamp01(v.y), Mathf.Clamp01(v.z), worldPoints[i].w));
            }

            RenderTexture.active = rt;
            GL.PushMatrix();
            GL.LoadOrtho();
            GL.Begin(GL.TRIANGLES);
            int trisCount = worldPoints.Count / 3;

            GCommon.SetMaterialKeywordActive(mat, "FALLOFF", true);
            mat.SetPass(pass);
            for (int i = 0; i < trisCount; ++i)
            {
                Vector4 v0 = worldPoints[i * 3 + 0];
                Vector4 v1 = worldPoints[i * 3 + 1];
                Vector4 v2 = worldPoints[i * 3 + 2];

                if (v0.w == 0 || v1.w == 0 || v2.w == 0)
                {
                    Vector4 vn0 = normalizedPoints[i * 3 + 0];
                    Vector4 vn1 = normalizedPoints[i * 3 + 1];
                    Vector4 vn2 = normalizedPoints[i * 3 + 2];

                    GL.MultiTexCoord3(0, vn0.x, vn0.z, vn0.y);
                    GL.MultiTexCoord3(1, v0.x, v0.z, v0.y);
                    GL.Color(new Color(vn0.w, vn0.w, vn0.w, vn0.w));
                    GL.Vertex3(vn0.x, vn0.z, vn0.y);

                    GL.MultiTexCoord3(0, vn1.x, vn1.z, vn1.y);
                    GL.MultiTexCoord3(1, v1.x, v1.z, v1.y);
                    GL.Color(new Color(vn1.w, vn1.w, vn1.w, vn1.w));
                    GL.Vertex3(vn1.x, vn1.z, vn1.y);

                    GL.MultiTexCoord3(0, vn2.x, vn2.z, vn2.y);
                    GL.MultiTexCoord3(1, v2.x, v2.z, v2.y);
                    GL.Color(new Color(vn2.w, vn2.w, vn2.w, vn2.w));
                    GL.Vertex3(vn2.x, vn2.z, vn2.y);
                }
            }
            GL.End();

            GL.Begin(GL.TRIANGLES);
            GCommon.SetMaterialKeywordActive(mat, "FALLOFF", false);
            mat.SetPass(pass);
            for (int i = 0; i < trisCount; ++i)
            {
                Vector4 v0 = worldPoints[i * 3 + 0];
                Vector4 v1 = worldPoints[i * 3 + 1];
                Vector4 v2 = worldPoints[i * 3 + 2];

                if (v0.w != 0 && v1.w != 0 && v2.w != 0)
                {
                    Vector4 vn0 = normalizedPoints[i * 3 + 0];
                    Vector4 vn1 = normalizedPoints[i * 3 + 1];
                    Vector4 vn2 = normalizedPoints[i * 3 + 2];

                    GL.MultiTexCoord3(0, vn0.x, vn0.z, vn0.y);
                    GL.MultiTexCoord3(1, v0.x, v0.z, v0.y);
                    GL.Color(new Color(vn0.w, vn0.w, vn0.w, vn0.w));
                    GL.Vertex3(vn0.x, vn0.z, vn0.y);

                    GL.MultiTexCoord3(0, vn1.x, vn1.z, vn1.y);
                    GL.MultiTexCoord3(1, v1.x, v1.z, v1.y);
                    GL.Color(new Color(vn1.w, vn1.w, vn1.w, vn1.w));
                    GL.Vertex3(vn1.x, vn1.z, vn1.y);

                    GL.MultiTexCoord3(0, vn2.x, vn2.z, vn2.y);
                    GL.MultiTexCoord3(1, v2.x, v2.z, v2.y);
                    GL.Color(new Color(vn2.w, vn2.w, vn2.w, vn2.w));
                    GL.Vertex3(vn2.x, vn2.z, vn2.y);
                }
            }
            GL.End();
            GL.PopMatrix();
            RenderTexture.active = null;
        }
        internal void DrawSpriteGlyphDF(Texture2D texture, Vector4 dest, Vector4 source, Color color, float font_scale)
        {
            if (!m_DrawString_InProgress)
                Logging.Fatal("BeginDrawString() must be called before DrawSpriteGlyph()");

            Vector4 uv = new Vector4(
                (float)source.X / texture.Width,
                (float)source.Y / texture.Height,
                (float)(source.X + source.Z) / texture.Width,
                (float)(source.Y + source.W) / texture.Height);

            float smoothing = 0.4f * Math.Pow(0.333f, font_scale * 2f) + 0.05f;
            Vector4 extra = new Vector4(0, 0, smoothing, 2);

            VertexPositionTextureHueExtra[] v = new VertexPositionTextureHueExtra[4]
            {
                new VertexPositionTextureHueExtra(new Vector3(dest.X, dest.Y, m_DrawString_Depth), new Vector2(uv.X, uv.Y), color, extra), // top left
                new VertexPositionTextureHueExtra(new Vector3(dest.X + dest.Z, dest.Y, m_DrawString_Depth), new Vector2(uv.Z, uv.Y), color, extra), // top right
                new VertexPositionTextureHueExtra(new Vector3(dest.X, dest.Y + dest.W, m_DrawString_Depth), new Vector2(uv.X, uv.W), color, extra), // bottom left
                new VertexPositionTextureHueExtra(new Vector3(dest.X + dest.Z, dest.Y + dest.W, m_DrawString_Depth), new Vector2(uv.Z, uv.W), color, extra) // bottom right
            };

            for (int i = 0; i < 4; i++)
                m_DrawString_VertexList.Add(v[i]);
        }