Exemple #1
0
        public void Editor_DrawLivePreview(GStylizedTerrain terrain, GTexturePainterArgs args, Camera cam)
        {
#if UNITY_EDITOR
            Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
            for (int i = 0; i < uvCorners.Length; ++i)
            {
                uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
            }

            Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);
            if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
            {
                return;
            }

            Texture2D     bg = terrain.TerrainData.Geometry.HeightMap;
            int           heightMapResolution = terrain.TerrainData.Geometry.HeightMapResolution;
            RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(terrain, heightMapResolution);
            GCommon.CopyToRT(bg, rt);

            Texture2D remapTex = GCommon.CreateTextureFromCurve(GTexturePainterCustomParams.Instance.Remap.Curve, 512, 1);
            Material  mat      = GInternalMaterials.RemapPainterMaterial;
            mat.SetTexture("_MainTex", bg);
            mat.SetTexture("_Mask", args.Mask);
            mat.SetFloat("_Opacity", args.Opacity);
            mat.SetTexture("_RemapTex", remapTex);
            int pass = 0;
            GCommon.DrawQuad(rt, uvCorners, mat, pass);

            GLivePreviewDrawer.DrawGeometryLivePreview(terrain, cam, rt, dirtyRect);

            GUtilities.DestroyObject(remapTex);
#endif
        }
Exemple #2
0
 public void Internal_UpdateFalloffTexture()
 {
     if (falloffTexture != null)
     {
         GUtilities.DestroyObject(falloffTexture);
     }
     falloffTexture = GCommon.CreateTextureFromCurve(Falloff, 256, 1);
 }
        public void UpdateCurveTextures()
        {
            if (heightTransitionTexture != null)
            {
                GUtilities.DestroyObject(heightTransitionTexture);
            }
            if (slopeTransitionTexture != null)
            {
                GUtilities.DestroyObject(slopeTransitionTexture);
            }
            if (noiseRemapTexture != null)
            {
                GUtilities.DestroyObject(noiseRemapTexture);
            }

            heightTransitionTexture = GCommon.CreateTextureFromCurve(HeightTransition, 256, 1);
            slopeTransitionTexture  = GCommon.CreateTextureFromCurve(SlopeTransition, 256, 1);
            noiseRemapTexture       = GCommon.CreateTextureFromCurve(NoiseRemap, 256, 1);
        }
        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
        {
            GCurveParams  curveParam     = param.Curve;
            RenderTexture bg             = CloneBg(targetRt);
            Texture2D     masterCurveTex = GCommon.CreateTextureFromCurve(curveParam.MasterCurve, 1024, 1);
            Texture2D     redCurveTex    = GCommon.CreateTextureFromCurve(curveParam.RedCurve, 1024, 1);
            Texture2D     greenCurveTex  = GCommon.CreateTextureFromCurve(curveParam.GreenCurve, 1024, 1);
            Texture2D     blueCurveTex   = GCommon.CreateTextureFromCurve(curveParam.BlueCurve, 1024, 1);
            Texture2D     alphaCurveTex  = GCommon.CreateTextureFromCurve(curveParam.AlphaCurve, 1024, 1);

            Mat.SetTexture("_MainTex", bg);
            Mat.SetTexture("_MasterCurve", masterCurveTex);
            Mat.SetTexture("_RedCurve", redCurveTex);
            Mat.SetTexture("_GreenCurve", greenCurveTex);
            Mat.SetTexture("_BlueCurve", blueCurveTex);
            Mat.SetTexture("_AlphaCurve", alphaCurveTex);
            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);

            GUtilities.DestroyObject(masterCurveTex);
            GUtilities.DestroyObject(redCurveTex);
            GUtilities.DestroyObject(greenCurveTex);
            GUtilities.DestroyObject(blueCurveTex);
            GUtilities.DestroyObject(alphaCurveTex);
        }
        public void Paint(Pinwheel.Griffin.GStylizedTerrain terrain, GTexturePainterArgs args)
        {
            if (terrain.TerrainData == null)
            {
                return;
            }
            if (args.MouseEventType == GPainterMouseEventType.Down)
            {
                terrain.ForceLOD(0);
                GRuntimeSettings.Instance.isEditingGeometry = true;
            }
            if (args.MouseEventType == GPainterMouseEventType.Up)
            {
                terrain.ForceLOD(-1);
                GRuntimeSettings.Instance.isEditingGeometry = false;
                terrain.UpdateTreesPosition();
                terrain.UpdateGrassPatches();
                terrain.TerrainData.Foliage.ClearTreeDirtyRegions();
                terrain.TerrainData.Foliage.ClearGrassDirtyRegions();
                return;
            }

            Vector2[] uvCorners = new Vector2[args.WorldPointCorners.Length];
            for (int i = 0; i < uvCorners.Length; ++i)
            {
                uvCorners[i] = terrain.WorldPointToUV(args.WorldPointCorners[i]);
            }

            Rect dirtyRect = GUtilities.GetRectContainsPoints(uvCorners);

            if (!dirtyRect.Overlaps(new Rect(0, 0, 1, 1)))
            {
                return;
            }

            Texture2D     bg = terrain.TerrainData.Geometry.HeightMap;
            int           heightMapResolution = terrain.TerrainData.Geometry.HeightMapResolution;
            RenderTexture rt = GTerrainTexturePainter.Internal_GetRenderTexture(heightMapResolution);

            GCommon.CopyToRT(bg, rt);

            Texture2D remapTex = GCommon.CreateTextureFromCurve(GTexturePainterCustomParams.Instance.Remap.Curve, 512, 1);
            Material  mat      = GInternalMaterials.RemapPainterMaterial;

            mat.SetTexture("_MainTex", bg);
            mat.SetTexture("_Mask", args.BrushMask);
            mat.SetFloat("_Opacity", Mathf.Pow(args.Opacity, GTerrainTexturePainter.GEOMETRY_OPACITY_EXPONENT));
            mat.SetTexture("_RemapTex", remapTex);
            if (args.EnableTerrainMask)
            {
                mat.SetTexture("_TerrainMask", terrain.TerrainData.Mask.MaskMap);
            }
            else
            {
                mat.SetTexture("_TerrainMask", Texture2D.blackTexture);
            }
            int pass = 0;

            GCommon.DrawQuad(rt, uvCorners, mat, pass);

            RenderTexture.active = rt;
            terrain.TerrainData.Geometry.HeightMap.ReadPixels(
                new Rect(0, 0, heightMapResolution, heightMapResolution), 0, 0);
            terrain.TerrainData.Geometry.HeightMap.Apply();
            RenderTexture.active = null;

            GUtilities.DestroyObject(remapTex);

            terrain.TerrainData.Geometry.SetRegionDirty(dirtyRect);
            terrain.TerrainData.Foliage.SetTreeRegionDirty(dirtyRect);
            terrain.TerrainData.Foliage.SetGrassRegionDirty(dirtyRect);
            terrain.TerrainData.SetDirty(GTerrainData.DirtyFlags.Geometry);
        }
 public void Internal_UpdateFalloffTexture()
 {
     falloffTexture = GCommon.CreateTextureFromCurve(Falloff, 256, 1);
 }