public void EditNormSpec(VoxelEditor ve)
{
typeNormSpecFoldout = EditorGUILayout.Foldout(typeNormSpecFoldout, "Voxel Type / Normal Power[-8,+8] / Spec Power[-8,+8]");
if (typeNormSpecFoldout)
{
for (int i = 0; i < 256; i++)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("" + i + ":", GUILayout.Width(32));
normspecPowers[i].x = EditorGUILayout.Slider(normspecPowers[i].x, -8f, +8f, GUILayout.Width(180));
normspecPowers[i].y = EditorGUILayout.Slider(normspecPowers[i].y, 0f, +4f, GUILayout.Width(160));
EditorGUILayout.EndHorizontal();
}
}
if (GUILayout.Button("Apply"))
{
for (int i = 0; i < 256; i++)
{
normspecTexture.SetPixel(i, 0, new Color(0.5f + normspecPowers[i].x / 16, normspecPowers[i].y / 4, 0.5f, 1f));
}
if (ve.m_voxelTerrain != null && ve.m_voxelTerrain._defMat != null)
{
ve.m_voxelTerrain._defMat.SetTexture("_NormSpecPowerTex", normspecTexture);
normspecTexture.Apply();
}
byte[] pixles = normspecTexture.EncodeToPNG();
System.IO.File.WriteAllBytes("Assets/Resources/terrainNormSpec.png", pixles);
}
}
public override void OnInspectorGUI()
{
VoxelEditor ve = (VoxelEditor)target as VoxelEditor;
GUILayout.BeginHorizontal();
GUILayout.Space(indent);
GUILayout.BeginVertical();
EditModeGui(ve);
switch (ve.m_eEditMode)
{
case VoxelEditor.EEditMode.eEditNormSpec:
EditNormSpec(ve);
break;
case VoxelEditor.EEditMode.eEditVoxel:
EditVoxelGui(ve);
break;
case VoxelEditor.EEditMode.eEditVegetables:
EditPlantGui(ve);
break;
}
GUILayout.EndVertical();
GUILayout.EndHorizontal();
}
public override void OnInspectorGUI()
{
serializedObject.Update();
serializedObject.ApplyModifiedProperties();
currentMaterialId = EditorGUILayout.IntSlider(currentMaterialId, 1, 50);
EditorGUILayout.PropertyField(voxelAtlasFileProperty, true);
EditorGUILayout.PropertyField(worldDimensionsProperty, true);
EditorGUILayout.PropertyField(brickResolutionProperty, true);
EditorGUILayout.PropertyField(maxDimensionsProperty, true);
VoxelEditor editor = (VoxelEditor)target;
currentMaterial = editor.materialAtlas.GetVoxelMaterial((byte)currentMaterialId);
if (GUILayout.Button("Brush: Place"))
{
currentBrush = setAdjacentBrush;
}
if (GUILayout.Button("Brush: Remove"))
{
currentMaterial = editor.materialAtlas.GetVoxelMaterial(0);
currentBrush = setBrush;
}
serializedObject.ApplyModifiedProperties();
serializedObject.Update();
EditorUtility.SetDirty(target);
}
public void DrawBrushGui(VoxelEditor ve)
{
int i = 0;
int count = 0;
GUILayout.BeginHorizontal();
count = (int)VoxelEditor.EBrushType.eBrushMax;
GUIContent[] brushToolbarContents = new GUIContent[count];
for (i = 0; i < count; i++)
{
brushToolbarContents[i] = new GUIContent(((VoxelEditor.EBrushType)i).ToString(), brushIcons[i]);
}
ve.m_eBuildBrush = (VoxelEditor.EBrushType)GUILayout.Toolbar((int)ve.m_eBuildBrush, brushToolbarContents, GUILayout.Width(120 * count), GUILayout.Height(32));
ve.m_drawGizmo = GUILayout.Toggle(ve.m_drawGizmo, new GUIContent("Draw\nBrush"));
GUILayout.EndHorizontal();
if (ve.m_eBuildBrush == VoxelEditor.EBrushType.eTerStyleBrush && ve.terBrushTextures.Count > 0)
{
GUILayout.BeginHorizontal();
GUIContent[] terToolbarContents = new GUIContent[ve.terBrushTextures.Count];
for (i = 0; i < ve.terBrushTextures.Count; i++)
{
terToolbarContents[i] = new GUIContent(ve.terBrushTextures[i]);
}
ve.terBrushType = GUILayout.Toolbar(ve.terBrushType, terToolbarContents, GUILayout.Width(64 * ve.terBrushTextures.Count), GUILayout.Height(64));
ve.terBrushProjector.material.SetTexture("_ShadowTex", ve.terBrushTextures[ve.terBrushType]);
GUILayout.Label("Note: Painting voxel materials automatically.");
GUILayout.EndHorizontal();
brushIcons[2] = ve.terBrushTextures[ve.terBrushType];
}
}
void Start()
{
m_voxelEditor = GameObject.Find("Voxel Terrain").GetComponent <VoxelEditor>();
//int m_maxRow = (int)(m_terrainSize / m_moveStep); //地形范围除以子地形范围, 比如 24576.0f / 256.0f = 96
//int m_maxRowDec1 = m_maxRow - 1;
// int m_maxCol = m_maxRow; //地形范围除以子地形范围, 比如 24576.0f / 256.0f = 96
// int m_maxColDec1 = m_maxRowDec1;
}
public void EditVoxelGui(VoxelEditor ve)
{
int i = 0;
int count = 0;
GUILayout.BeginHorizontal();
count = 5;
GUIContent[] buildTypeToolbarContents = new GUIContent[count];
for (i = 0; i < count; i++)
{
buildTypeToolbarContents[i] = new GUIContent(((VoxelEditor.EBuildType)i).ToString());
}
ve.m_eBuildType = (VoxelEditor.EBuildType)GUILayout.Toolbar((int)ve.m_eBuildType, buildTypeToolbarContents, GUILayout.Width(77 * count), GUILayout.Height(24));
GUILayout.EndHorizontal();
ve.m_alterRadius = EditorGUILayout.Slider("Alter Radius", ve.m_alterRadius, 1, 128, GUILayout.Width(384));
GUI.enabled = ve.m_eBuildType != VoxelEditor.EBuildType.eBuildVoxel || !ve.m_bPaintVoxelTypeMode;
if (ve.m_eBuildType == VoxelEditor.EBuildType.eFlatten)
{
ve.m_alterDstH = EditorGUILayout.Slider("Alter DstHeight", ve.m_alterDstH, 1, 999, GUILayout.Width(384));
}
else
{
ve.m_alterPower = EditorGUILayout.Slider("Alter Power", ve.m_alterPower, 0.5f, 2.0f, GUILayout.Width(384));
}
GUI.enabled = ve.m_eBuildBrush != VoxelEditor.EBrushType.eTerStyleBrush;
ve.m_eVoxelTerrainSet = (VoxelEditor.EVoxelTerrainSet)EditorGUILayout.EnumPopup("VoxelType Set", ve.m_eVoxelTerrainSet, GUILayout.Width(384));
ve.m_eVoxelTerrainSubSet = (VoxelEditor.EVoxelTerrainSubSet)EditorGUILayout.EnumPopup("VoxelType Subset", ve.m_eVoxelTerrainSubSet, GUILayout.Width(384));
GUI.enabled = true;
switch (ve.m_eBuildType)
{
case VoxelEditor.EBuildType.eBuildVoxel:
ve.m_bPaintVoxelTypeMode = EditorGUILayout.Toggle("Paint Material Mode", ve.m_bPaintVoxelTypeMode, GUILayout.Width(384));
DrawBrushGui(ve);
break;
case VoxelEditor.EBuildType.eFlatten:
break;
case VoxelEditor.EBuildType.eSmoothVoxel:
ve.m_voxelFilterSize = EditorGUILayout.IntSlider("Voxel Filter Size", ve.m_voxelFilterSize, 1, 16, GUILayout.Width(384));
break;
case VoxelEditor.EBuildType.eGrowNoise:
ve.m_NoiseStrength = EditorGUILayout.Slider("Noise Strength", ve.m_NoiseStrength, 0, 10, GUILayout.Width(384));
ve.m_GrowNoiseCooldown = EditorGUILayout.Slider("Grow Noise Cooldown", ve.m_GrowNoiseCooldown, 0, 10, GUILayout.Width(384));
break;
case VoxelEditor.EBuildType.ePlantFilter:
ve.FilterMap = (Texture2D)EditorGUILayout.ObjectField("Filter Map", ve.FilterMap, typeof(Texture2D), true, GUILayout.Width(384));
ve.shootingOffset = EditorGUILayout.Slider("Shooting Offset", ve.shootingOffset, 0, 128, GUILayout.Width(384));
ve.PlantFilterWeightDivisor = EditorGUILayout.IntSlider("Plant Filter Weight Divisor", ve.PlantFilterWeightDivisor, 0, 500, GUILayout.Width(384));
ve.EdgeWeight = EditorGUILayout.IntSlider("Edge Weight", ve.EdgeWeight, 0, 128, GUILayout.Width(384));
break;
}
}
public void OnDisable()
{
EditNormSpecOnDisable();
VoxelEditor ve = (VoxelEditor)target as VoxelEditor;
if (ve.terBrushProjector != null)
{
DestroyImmediate(ve.terBrushProjector.gameObject);
}
}
void OnEnable()
{
voxelAtlasFileProperty = serializedObject.FindProperty("voxelAtlasFile");
worldDimensionsProperty = serializedObject.FindProperty("worldDimensions");
brickResolutionProperty = serializedObject.FindProperty("brickResolution");
maxDimensionsProperty = serializedObject.FindProperty("maxDimensions");
currentBrush = setAdjacentBrush;
VoxelEditor editor = (VoxelEditor)target;
}
void Awake()
{
m_this = this;
//ms_isSubTerrainOdtGen = false;
if (GameConfig.IsMultiMode)
{
enabled = false;
}
else
{
enabled = true;
}
}
public void EditModeGui(VoxelEditor ve)
{
int i = 0;
int count = 0;
GUILayout.BeginHorizontal();
count = 3;
GUIContent[] modeToolbarContents = new GUIContent[count];
for (i = 0; i < count; i++)
{
modeToolbarContents[i] = new GUIContent(((VoxelEditor.EEditMode)i).ToString());
}
ve.m_eEditMode = (VoxelEditor.EEditMode)GUILayout.Toolbar((int)ve.m_eEditMode, modeToolbarContents, GUILayout.Width(128 * count), GUILayout.Height(24));
GUILayout.EndHorizontal();
}
void Load()
{
string prefabName = "Layered Random SubTerrain Group";
GameObject objGrass = Object.Instantiate(Resources.Load <GameObject>(prefabName)) as GameObject;
if (null == objGrass)
{
Debug.LogError("can't find tree prefab:" + prefabName);
return;
}
RSubTerrainMgr.Instance.CameraTransform = Camera.main.transform;
RSubTerrainMgr.Instance.VEditor = VoxelEditor.Get();
RSubTerrSL.Init();
}
private void Awake()
{
voxelEditor = FindObjectOfType <VoxelEditor>();
infiniteGeneration = FindObjectOfType <InfiniteGeneration>();
worldManager = FindObjectOfType <WorldManager>();
chunkSaveLoadManager = FindObjectOfType <ChunkSaveLoadManager>();
player = FindObjectOfType <PlayerController>().transform;
BlockCollection blockList = BlockManager.ReadBlocks();
chunkResolution = 16;
recycleableChunks = new Queue <VoxelChunk>();
worldScriptableObject.pathName = worldManager.worldPath + "/" + worldManager.worldName;
worldScriptableObject.seed = worldManager.seed;
FreshGeneration();
}
public void CreateBlocks()
{
// if (camOp.FirstPerson)
// {
// Vector3 camForward = Vector3.Scale(Game.MainCamera.transform.forward, new Vector3(1, 0, 1)).normalized;
// Vector3 editLocation = transform.position + camForward;
// World3 editBlock = World.GetBlockPosition(editLocation);
// ushort block = World.GetBlock(editBlock);
// if (block == Block.Air)
// {
// VoxelEditor.SetBlock(editBlock, Blocks.Glass(0));
// }
// }
// else
// {
for (int x = -1; x < 2; x++)
{
for (int y = -3; y < 0; y++)
{
for (int z = -1; z < 2; z++)
{
Vector3 editLocation = new Vector3(
gameObject.transform.position.x + x,
gameObject.transform.position.y + y,
gameObject.transform.position.z + z);
World3 editBlock = World.GetBlockPosition(editLocation);
ushort block = World.GetBlock(editBlock);
if (block == Block.Air)
{
VoxelEditor.SetBlock(editBlock, Blocks.Glass(0));
}
}
}
}
//}
}
public void EditPlantGui(VoxelEditor ve)
{
GUILayout.BeginHorizontal();
ve.m_buildStartIdx = EditorGUILayout.IntSlider("StartIdx", ve.m_buildStartIdx, 0, ve.m_treePrototypeList.Length, GUILayout.Width(192));
ve.m_buildRange = EditorGUILayout.IntSlider("Range", ve.m_buildRange, 0, ve.m_treePrototypeList.Length, GUILayout.Width(192));
GUILayout.EndHorizontal();
ve.m_buildDensity = EditorGUILayout.IntSlider("Density", ve.m_buildDensity, 0, 500, GUILayout.Width(192));
GUILayout.BeginHorizontal();
ve.m_baseWidthScale = EditorGUILayout.Slider("Base W Scale", ve.m_baseWidthScale, 0, 5, GUILayout.Width(192));
ve.m_baseHeightScale = EditorGUILayout.Slider("Base H Scale", ve.m_baseHeightScale, 0, 5, GUILayout.Width(192));
GUILayout.EndHorizontal();
ve.m_baseColor = EditorGUILayout.ColorField("Base Color", ve.m_baseColor, GUILayout.Width(192));
ve.m_maxBuildAngle = EditorGUILayout.Slider("Max Build Angle", ve.m_maxBuildAngle, 0, 90, GUILayout.Width(192));
DrawArray(ref ve.m_treePrototypeList, ref bFoldoutTreePrototypeList, "TreePrototype List");
DrawArray(ref ve.m_treePrototypeBendfactor, ref bFoldoutTreePrototypeBendfactor, "TreePrototype Bend Factor");
DrawArray(ref ve.m_treePrototypeSizes, ref bFoleoutTreePrototypeSizes, "TreePrototype Size");
string[] treePrototypeName = ve.m_treePrototypeName.ToArray();
DrawArray(ref treePrototypeName, ref bFoldoutTreePrototypeNames, "TreePrototype Name");
ve.m_treePrototypeName = treePrototypeName.ToList();
}
public void Connect(
CurveTool.CurveTool curveTool,
IDRenderer idRenderer,
LineRenderer lineRenderer,
MainSceneRenderer mainSceneRenderer,
ManipulatorManager manipulatorManager,
Map map,
MaterialManager materialManager,
IRenderer renderer,
SceneManager sceneManager,
SelectionManager selectionManager,
ShadowRenderer shadowRenderer,
StereoscopicRenderer stereoscopicRenderer,
UserInterfaceManager userInterfaceManager,
VoxelEditor voxelEditor,
OpenTK.GameWindow window
)
{
this.curveTool = curveTool;
this.idRenderer = idRenderer;
this.lineRenderer = lineRenderer;
this.mainSceneRenderer = mainSceneRenderer;
this.manipulatorManager = manipulatorManager;
this.map = map;
this.materialManager = materialManager;
this.renderer = renderer;
this.sceneManager = sceneManager;
this.selectionManager = selectionManager;
this.shadowRenderer = shadowRenderer;
this.stereoscopicRenderer = stereoscopicRenderer;
this.userInterfaceManager = userInterfaceManager;
this.voxelEditor = voxelEditor;
this.window = window;
InitializationDependsOn(map);
InitializationDependsOn(materialManager);
}
// Use this for initialization
void OnSceneGUI()
{
Event e = Event.current;
// We use hotControl to lock focus onto the editor (to prevent deselection)
int controlID = GUIUtility.GetControlID(FocusType.Passive);
VoxelEditor editor = (VoxelEditor)target;
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (Event.current.button == 1)
{
Selection.activeGameObject = null;
}
GUIUtility.hotControl = controlID;
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
editor.PaintWithRay(ray, currentBrush, currentMaterial);
Event.current.Use();
break;
case EventType.MouseUp:
GUIUtility.hotControl = 0;
Event.current.Use();
break;
}
}
public void CreateSphere()
{
VoxelEditor.SetSphere(World.GetBlockPosition(transform.position), Blocks.Glass(0), 50);
}
public void NotInEditGui(VoxelEditor ve)
{
GUILayout.BeginHorizontal();
GUILayout.Space(indent);
GUILayout.EndHorizontal();
}
public void OnEnable()
{
VoxelEditor ve = (VoxelEditor)target as VoxelEditor;
EditNormSpecOnEnable(ve.gameObject);
if (ve.m_boxBrushPrefab == null)
{
ve.m_boxBrushPrefab = (GameObject)AssetDatabase.LoadAssetAtPath("Assets/Prefabs/GizmoCube.prefab", typeof(GameObject));
}
if (ve.m_sphereBrushPrefab == null)
{
ve.m_sphereBrushPrefab = (GameObject)AssetDatabase.LoadAssetAtPath("Assets/Prefabs/GizmoSphere.prefab", typeof(GameObject));
}
if (brushIcons == null || brushIcons.Length != (int)VoxelEditor.EBrushType.eBrushMax)
{
brushIcons = new Texture2D[(int)VoxelEditor.EBrushType.eBrushMax];
}
if (brushIcons[0] == null)
{
brushIcons[0] = AssetPreview.GetAssetPreview(ve.m_boxBrushPrefab);
}
if (brushIcons[1] == null)
{
brushIcons[1] = AssetPreview.GetAssetPreview(ve.m_sphereBrushPrefab);
}
//if(ve.terBrushTextures.Count == 0)
{
ve.terBrushTextures.Clear();
string[] strBrushTextures = System.IO.Directory.GetFiles("Assets/Resources/WaterTile", "brush*.png");
for (int i = 0; i < strBrushTextures.Length; i++)
{
string strBrushTex = Path.GetFileNameWithoutExtension(strBrushTextures[i]);
ve.terBrushTextures.Add((Texture2D)Resources.Load("WaterTile/" + strBrushTex));
}
}
if (ve.terBrushProjector == null)
{
Transform prjTransform = ve.gameObject.transform.parent.FindChild("TmpPrj");
if (prjTransform == null)
{
GameObject go = new GameObject("TmpPrj");
prjTransform = go.transform;
prjTransform.parent = ve.gameObject.transform.parent;
}
GameObject projectorGo = prjTransform.gameObject;
if ((ve.terBrushProjector = projectorGo.GetComponent <Projector>()) == null)
{
ve.terBrushProjector = projectorGo.AddComponent <Projector>();
ve.terBrushProjector.transform.localEulerAngles = new Vector3(90, 0, 0);
ve.terBrushProjector.orthographic = true;
ve.terBrushProjector.farClipPlane = 1500;
ve.terBrushProjector.ignoreLayers = ~(1 << Pathea.Layer.VFVoxelTerrain);
if (ve.terBrushProjector.material == null)
{
ve.terBrushProjector.material = (Material)Instantiate(Resources.Load("WaterTile/brushMat"));
}
//ve.terBrushProjector.material.SetTexture("_ShadowTex", waterPlane.brushTextures[waterPlane.brushType]);
}
ve.terBrushProjector.enabled = false;
}
if (brushIcons[2] == null)
{
brushIcons[2] = ve.terBrushTextures[ve.terBrushType];
}
}
public bool BashBlocks(Vector3 forward, float speed, bool boosting, bool jumping, bool firstPerson)
{
//Game.Log("Speed: " + speed.ToString("N2") + " Contacts: " + collision.contacts.Length);
bool groundPounded = false;
bool hit = false;
List <Vector3> normals = new List <Vector3>();
if (groundPoundEnabled && groundPound)
{
// Normals for a 3x3 square below the player
normals.Add(Vector3.down);
normals.Add(new Vector3(1, -1, 0));
normals.Add(new Vector3(0, -1, 1));
normals.Add(new Vector3(-1, -1, 0));
normals.Add(new Vector3(0, -1, -1));
normals.Add(new Vector3(1, -1, 1));
normals.Add(new Vector3(-1, -1, 1));
normals.Add(new Vector3(1, -1, -1));
normals.Add(new Vector3(-1, -1, -1));
}
else
{
// Try to hit with the forward normal, fall back to a radial search
// TODO: be more selective with search angles
if ((!grounded || jumping) || firstPerson)
{
// Blocks above the player
normals.Add(Vector3.up);
normals.Add(new Vector3(1, 1, 0));
normals.Add(new Vector3(0, 1, 1));
normals.Add(new Vector3(-1, 1, 0));
normals.Add(new Vector3(0, 1, -1));
normals.Add(new Vector3(1, 1, 1));
normals.Add(new Vector3(-1, 1, 1));
normals.Add(new Vector3(1, 1, -1));
normals.Add(new Vector3(-1, 1, -1));
}
if (firstPerson && (!grounded || jumping))
{
// Blocks above the player
normals.Add(new Vector3(0, 2, 0));
normals.Add(new Vector3(1, 2, 0));
normals.Add(new Vector3(0, 2, 1));
normals.Add(new Vector3(-1, 2, 0));
normals.Add(new Vector3(0, 2, -1));
normals.Add(new Vector3(1, 2, 1));
normals.Add(new Vector3(-1, 2, 1));
normals.Add(new Vector3(1, 2, -1));
normals.Add(new Vector3(-1, 2, -1));
}
normals.Add(forward);
normals.Add(new Vector3(1, 0, 0));
normals.Add(new Vector3(0, 0, 1));
normals.Add(new Vector3(-1, 0, 0));
normals.Add(new Vector3(0, 0, -1));
normals.Add(new Vector3(1, 0, 1));
normals.Add(new Vector3(-1, 0, 1));
normals.Add(new Vector3(1, 0, -1));
normals.Add(new Vector3(-1, 0, -1));
}
Vector3 pos = transform.position;
foreach (Vector3 normal in normals)
{
int blockPosY = Mathf.FloorToInt(pos.y);
float offset = pos.y - ((float)blockPosY + 0.5f);
World3 b_pos;
if (!jumping)
{
b_pos = new World3(
Mathf.FloorToInt(pos.x + normal.x),
Mathf.FloorToInt(pos.y - offset + normal.y),
Mathf.FloorToInt(pos.z + normal.z)
);
}
else
{
b_pos = new World3(
Mathf.FloorToInt(pos.x + normal.x),
Mathf.FloorToInt(pos.y - offset + normal.y),
Mathf.FloorToInt(pos.z + normal.z)
);
}
bool bash = false;
// Don't break the floor!
if (b_pos.y > -48)
{
// same level and boost button held
if (b_pos.y == blockPosY && boosting)
{
bash = true;
}
// 1 level below and ground pound active
if (b_pos.y < blockPosY && b_pos.y > blockPosY - 2 && groundPound)
{
bash = true;
}
// overhead and jumping
if (b_pos.y > blockPosY && (jumping || firstPerson))
{
bash = true;
}
}
else
{
groundPounded = true;
}
if (bash)
{
ushort bashBlock = World.GetBlock(b_pos);
if (bashBlock != Block.Null && bashBlock != Block.Air)
{
VoxelEditor.SetBlock(b_pos, Block.Air, true);
hit = true;
if (b_pos.y < Mathf.RoundToInt(pos.y))
{
groundPounded = true;
}
TileColor tileColor = Blocks.GetColor(bashBlock);
Color color = new Color(tileColor.r, tileColor.g, tileColor.b);
//if (Game.CameraOp.Distance > 5f)
//{
SpawnPickupsFromBlock(b_pos, color);
//}
}
}
}
if (groundPounded)
{
if (!IsInvoking("DisableGroundPound"))
{
Invoke("DisableGroundPound", 0.05f);
}
}
return(hit);
}
