public void Test()
{
//Teeb world geni randomiks
xOffset = Random.Range(0, 9999);
yOffset = Random.Range(0, 9999);
//Teeb kindlaks et mapi laiused oleksid paaritud arvud
if (width % 2 == 0)
{
width += 1;
}
if (heigth % 2 == 0)
{
heigth += 1;
}
//Genereerib noisemapi
float[,] noiseMap = NoiseGen.GenerateNoise(width, heigth, scale, levels, intensity, opacity, xOffset, yOffset, opacity2);
//DrawTexture drawScript = GetComponent<DrawTexture>();
//drawScript.DrawNoise(width,heigth,noiseMap);
MakeMesh makeMesh = GetComponent <MakeMesh>();
makeMesh.CreateMesh(width, heigth, noiseMap, heigths, coast, waterLevel, mapRadius, animalSpawnDist);
}
public void Start()
{
stlHolder = GameObject.Find ("stlHolder").transform;
var tbSpace = 20;
GetComponent<InspectorL>().MainRect = new Rect(5, tbSpace, 250, 570);
windowStyle.fontSize = 50;
MM = GameObject.Find("MESH").GetComponent<MakeMesh>();
MM.material = Mat;
MM.Begin();
}
/// <summary>
/// <b>호출</b> : ElementPresenter.MakeWall()<br></br>
/// <b>참조</b> : CalcPadding(),FindRotateAngle(), MakeMesh.MakeWalls(), Outliner.FindAllOutline()<br></br>
/// 문/창문 위치 반영한 벽 생성 함수.
/// Outliner로 방의 외곽선 점을 얻은 다음,
/// 그 점들을 따라 quad로 기준이 될 벽을 생성하고,
/// MakeMesh.MakeWalls()으로 기준 벽에 문/창문 오브젝트의 정보를 반영하여 새로운 벽 오브젝트를 생성한 뒤,
/// 생성된 오브젝트와 그 벽의 면적을 딕셔너리로 묶어서 저장하여 반환한다.
/// </summary>
/// <param name="rooms">모든 방 리스트</param>
/// <param name="elements">모든 문/창문 오브젝트 리스트</param>
/// <param name="height">벽 높이</param>
/// <param name="material">생성된 벽에 적용할 기본 재질</param>
/// <param name="wallParent">생성된 벽 오브젝트를 담을 부모 오브젝트</param>
/// <param name="isDebug">디버그 옵션</param>
/// <returns>생성된 벽 오브젝트와 벽의 면적을 담은 딕셔너리</returns>
public static Dictionary <Transform, float> MakeWalls(List <Transform> rooms, List <Transform> elements, float height, Material material, out Transform wallParent, bool isDebug = false)
{
Dictionary <Transform, float> generatedWallList = new Dictionary <Transform, float>();
wallParent = new GameObject().transform;
wallParent.transform.parent = rooms[0].parent;
wallParent.name = "Walls";
foreach (var room in rooms)
{
// 방 외곽선을 이루는 점 수집
List <Transform> subFloors = new List <Transform>();
for (int i = 0; i < room.childCount; i++)
{
subFloors.Add(room.GetChild(i));
}
Outliner outliner = new Outliner();
List <List <Dot> > allDots = outliner.FindAllOutline(subFloors);
// 외곽선을 따라 벽 오브젝트 생성
foreach (var dots in allDots)
{
for (int i = 0; i < dots.Count; i++)
{
Vector3 dot1 = dots[i].position;
Vector3 dot2 = dots[(i + 1) % dots.Count].position;
// quad로 기준 벽을 생성
Transform wall = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
float angle = FindRotateAngle(dot1, dot2);
Vector3 padding = CalcPadding(angle);
wall.position = (dot1 + dot2) * 0.5f + Vector3.up * height * 0.5f;
wall.GetComponent <Renderer>().material.color = Color.black;
wall.localScale = new Vector3(Mathf.Max(Mathf.Abs(dot1.x - dot2.x), Mathf.Abs(dot1.z - dot2.z)), height, 1);
wall.Rotate(Vector3.up * angle);
// 기준 벽과 문/창문 오브젝트 정보를 이용하여 새로운 벽 오브젝트 생성
Transform madeWall = MakeMesh.MakeWalls(wall, elements, material, out float area, isDebug).transform;
generatedWallList.Add(madeWall, area);
madeWall.parent = wallParent;
GameObject.Destroy(wall.gameObject);
}
}
}
return(generatedWallList);
}
/// <summary>
/// 공간설정 종료 후 문/창문 설치를 위한 벽(wallTop)과 병합된 바닥 생성.
/// </summary>
void MakeWallsAndFloors()
{
//테두리 제거
Transform borders = GameObject.Find("Borders").transform;
for (int i = 0; i < borders.childCount; i++)
{
Destroy(borders.GetChild(i).gameObject);
}
foreach (var room in model.Room.Rooms)
{
for (int i = 0; i < room.childCount; i++)
{
FloatFloor(room.GetChild(i), 0);
}
}
float border = 0.1f;
float height = 2.2f;
// 공간설정 완료하고 벽 세우기
Util.MakeWallTops(model.Room.Rooms, border, height);
//병합된 바닥 생성하기
Transform mergedFloorParent = new GameObject().transform;
mergedFloorParent.parent = model.Room.Rooms[0].parent;
mergedFloorParent.name = "MergedRooms";
int number = 0;
foreach (var room in model.Room.Rooms)
{
GameObject floor = MakeMesh.MakeRoomFloor(Util.GetChildTransform(room), out float area, isDebugMode);
model.Room.MergedRooms.Add(floor.transform, area);
if (floor != null)
{
floor.name = "Room" + (number++).ToString();
floor.transform.parent = mergedFloorParent;
floor.GetComponent <MeshRenderer>().material = model.Floor.DefaultFloorMaterial;
}
room.gameObject.SetActive(false);
}
SceneManager.LoadScene("ElementSettingScene");
}
/// <summary>
/// <b>호출</b> : ElementPresenter.MakeWall()<br></br>
/// <b>참조</b> : FindRotateAngle(), MakeMesh.MakeWalls(), Outliner.FindAllOutline()<br></br>
/// 외곽벽을 생성하는 함수.
/// Outliner를 이용하여 전체 방의 외곽 점을 수집한 뒤, 점사이 공간에 quad로 임시 벽을 생성한다.
/// 임시벽의 위치, 크기, 회전을 참조해서 문/창문 오브젝트를 고려한 벽을 MakeMesh 클래스를 이용하여 생성한다.
/// </summary>
/// <param name="allFloors">전체 바닥 정보</param>
/// <param name="elements">문/창문 리스트</param>
/// <param name="border">벽 두께</param>
/// <param name="height">벽 높이</param>
/// <param name="material">외곽벽 생성시 적용할 기본 오브젝트</param>
/// <returns>생성된 외곽벽 오브젝트를 담은 부모 오브젝트</returns>
public static GameObject MakeOutlineWalls(List <Transform> allFloors, List <Transform> elements, float border, float height, Material material)
{
// 위치,크기,회전 참조를 위해 quad로 임시 생성한 벽 오브젝트를 담을 부모 오브젝트
Transform wallParent = new GameObject().transform;
wallParent.name = "OutlineWalls";
// 문/창문 오브젝트를 고려하여 다시 생성한 벽 오브젝트를 담을 부모 오브젝트
Transform outlinewallParent = new GameObject().transform;
outlinewallParent.name = "OutlineWalls";
// 전체 방 외곽 점 수집
Outliner outliner = new Outliner();
List <List <Dot> > allDots = outliner.FindAllOutline(allFloors);
foreach (var dots in allDots)
{
for (int i = 0; i < dots.Count; i++)
{
Vector3 dot1 = dots[i].position;
Vector3 dot2 = dots[(i + 1) % dots.Count].position;
float angle = FindRotateAngle(dot1, dot2);
// 임시 벽 생성
Transform wall = GameObject.CreatePrimitive(PrimitiveType.Quad).transform;
wall.position = (dot1 + dot2) * 0.5f + Vector3.up * height * 0.5f;
wall.localScale = new Vector3(Mathf.Max(Mathf.Abs(dot1.x - dot2.x), Mathf.Abs(dot1.z - dot2.z)), height, 1);
wall.Rotate(Vector3.up * ((angle + 180) % 360));
wall.parent = wallParent;
// 문/창문 고려한 벽 생성
Transform madeWall = MakeMesh.MakeWalls(wall, elements, material, out float area).transform;
madeWall.parent = outlinewallParent;
madeWall.GetComponent <Renderer>().receiveShadows = false;
}
}
GameObject.Destroy(wallParent.gameObject);
return(outlinewallParent.gameObject);
}
public Curve(
bool isSelected,
bool isBeingDrawn,
bool isBeingMoving,
bool isClosed,
List <Vector3> positions,
Vector3 position,
Quaternion rotation)
{
this.isSelected = isSelected;
this.isBeingDrawn = isBeingDrawn;
this.isBeingMoved = isBeingMoving;
this.isClosed = isClosed;
this.positions = positions;
if (positions.Count >= 2)
{
this.mesh = MakeMesh.Curve(this.positions, this.meridian, this.radius, this.isClosed);
}
this.position = position;
this.rotation = rotation;
}
public IKnotState Update()
{
int ind1 = KnotStateChoose1.FindClosestPoint(this.data.oculusTouch, this.data.points);
var chosenPoints = new List <Vector3>()
{
this.data.points[ind1]
};
Mesh pointMesh = MakeMesh.GetMeshAtPoints(chosenPoints, this.data.radius * 3);
Graphics.DrawMesh(this.knotMesh, Vector3.zero, Quaternion.identity, this.data.curveMaterial, 0);
Graphics.DrawMesh(pointMesh, Vector3.zero, Quaternion.identity, this.data.pointMaterial, 0);
if (this.data.oculusTouch.GetButtonDown(this.data.buttonA))
{
return(new KnotStateChoose2(this.data, ind1));
}
else if (this.data.oculusTouch.GetButtonDown(this.data.buttonB))
{
return(new KnotStateBase(this.data));
}
return(null);
}
private void Start()
{
hunterScript = gameObject.GetComponent <HunterMethods>();
hunterVariables = gameObject.GetComponent <HunterVariables>();
worldScript = GameObject.FindWithTag("GenObject").GetComponent <MakeMesh>();
}
void Start ()
{
stlInterpreter = new StlInterpreter();
mainMenu = GameObject.Find("Main Menu");
folderWindow = GameObject.Find("Folder Window");
sceneWindow = GameObject.Find("Scene Window");
folderWindow.GetComponent<PanelFades>().FadeOut();
sceneWindow.GetComponent<PanelFades>().FadeOut();
_cursor = Instantiate(cursor) as GameObject;
_cursor.transform.SetParent(mainMenu.transform);
var pos = Camera.main.ScreenToWorldPoint(new Vector3(Input.mousePosition.x, Input.mousePosition.y + mouseYoffset, -1f));
var rot = new Quaternion(0, 0, 0, 0);
_cursor.transform.localPosition = pos;
_cursor.transform.localRotation = rot;
MM = GameObject.Find("MESH").GetComponent<MakeMesh>();
MM.material = Mat;
MM.Begin();
for (int i = 0; i < landscapes.Count; i++)
{
var l = Instantiate(landscapes[i]);
l.name = landscapes[i].name;
l.active = false;
landscapes[i] = l;
}
for (int i = 0; i < props.Count; i++)
{
var p = Instantiate(props[i]);
p.name = props[i].name;
p.active = false;
props[i] = p;
}
var options = new List<Dropdown.OptionData>(skyboxes.Count);
foreach (var skybox in skyboxes)
{
var newOption = new Dropdown.OptionData(skybox.name);
options.Add(newOption);
}
skyboxDD.options = options;
options = new List<Dropdown.OptionData>(MM.materials.Count);
foreach (var mat in MM.materials)
{
var newOption = new Dropdown.OptionData(mat.name);
options.Add(newOption);
}
materialDD.options = options;
options = new List<Dropdown.OptionData>(landscapes.Count);
var none = new Dropdown.OptionData("None");
options.Add(none);
foreach (var landscape in landscapes)
{
var newOption = new Dropdown.OptionData(landscape.name);
options.Add(newOption);
}
landscapeDD.options = options;
options = new List<Dropdown.OptionData>(props.Count);
options.Add(none);
foreach (var prop in props)
{
var newOption = new Dropdown.OptionData(prop.name);
options.Add(newOption);
}
propDD.options = options;
currentProp = null;
materialDD.onValueChanged.AddListener(delegate {
MaterialDropdownValueChangedHandler(materialDD);
});
skyboxDD.onValueChanged.AddListener(delegate {
SkyboxDropdownValueChangedHandler(skyboxDD);
});
landscapeDD.onValueChanged.AddListener(delegate {
LandscapeDropdownValueChangedHandler(landscapeDD);
});
propDD.onValueChanged.AddListener(delegate {
PropDropdownValueChangedHandler(propDD);
});
}
public static MeshData GetMeshData(Vector2[] line, float width, int materialNum, float zValue)
{
return(MakeMesh.MakeMain(line, width, materialNum, zValue));
}
public static MeshData GetMeshDataMk2(Vector2[] line, float width, int materialLeft, int materialMain, int materialRight, float zValue)
{
return(MakeMesh.MakeMainMk2(line, width, materialLeft, materialMain, materialRight, zValue));
}
public KnotStateChoose2(KnotData data, int ind1)
{
this.data = data;
this.knotMesh = MakeMesh.GetMesh(this.data.points, this.data.meridian, this.data.radius, true);
this.ind1 = ind1;
}
public KnotStateChoose1(KnotData data)
{
this.data = data;
this.knotMesh = MakeMesh.GetMesh(this.data.points, this.data.meridian, this.data.radius, true);
}
void Start()
{
MM = GameObject.Find("MESH").GetComponent<MakeMesh>();
}
public void MeshUpdate()
{
this.mesh = MakeMesh.Curve(this.positions, this.meridian, this.radius, this.isClosed);
}
void Start()
{
data = FindObjectOfType <Data>();
MeshMaker = GetComponent <MakeMesh>();
hexMesh = MeshMaker.GenerateHex();
}
void Start()
{
MM = GameObject.Find("MESH").GetComponent<MakeMesh>();
Min = new Vector3(1000, 1000, 1000);
Max = new Vector3(-1000, -1000, -1000);
gameObject.AddComponent<MeshFilter>();
gameObject.AddComponent<MeshRenderer>();
mesh = GetComponent<MeshFilter>().mesh;
mesh.Clear();
var rnd = GetComponent<MeshRenderer>();
rnd.material = material;
rnd.receiveShadows = true;
rnd.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.On;
}
/// <summary>
/// 오브젝트에 이벤트를 바인딩하는 함수.
/// 오브젝트와 항목 선택 상태에 따라 클릭 시 선택/취소 되거나, 재질이 적용되도록 함.
/// sliding door의 경우 애니메이션을 위해 문짝 모델을 분리하여 별도의 클릭 이벤트를 바인딩 해줌.
/// no door의 경우 이벤트 바인딩을 하는 대신에
/// 재질 적용릉 위해 벽지/천장/바닥 부분을 땜빵하는 Quad 모델을 Probuilder로 다시 생성함.
/// 이때 다시 생성된 mesh들은 nodoor mesh 부모 오브젝트 아래로 들어가서 벽지 또는 바닥재가 적용될 수 있도록 바인딩한다.
/// </summary>
/// <param name="item">바인딩 대상 오브젝트</param>
/// <param name="type">오브젝트 타입</param>
private void BindItem(Transform item, DecorateType type)
{
if (type == DecorateType.None)
{
type = FindType(item);
}
GameObject itemObject = (type == DecorateType.Furniture ? item.parent.gameObject : item.gameObject);
#region for door
Transform d = null;
float dir = 0;
Vector3 angle = Vector3.zero;
Vector3 localPosition = Vector3.zero;
// Sliding Door용 X좌표.
float defaultX = 0;
float defaultY = 0;
bool isMoving = false;
bool isOpen = false;
float startPos = 0, endPos = 0;
float animationTime = 0.5f;
float currentTime = 0;
if (type == DecorateType.Door)
{
if (type == DecorateType.Door && item.name == "NoDoor(Clone)")
{
GameObject mesh;
float area;
mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("WallL").gameObject, model.Floor.DefaultFloorMaterial, out area);
mesh.transform.parent = nodoorMeshParent;
nodoorMeshs.Add(mesh, area);
mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("WallR").gameObject, model.Floor.DefaultFloorMaterial, out area);
mesh.transform.parent = nodoorMeshParent;
nodoorMeshs.Add(mesh, area);
mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("Floor").gameObject, model.Floor.DefaultFloorMaterial, out area);
mesh.transform.parent = nodoorMeshParent;
nodoorMeshs.Add(mesh, area);
mesh = MakeMesh.MakeQuad(item.GetChild(0).Find("Ceiling").gameObject, model.Floor.DefaultFloorMaterial, out area);
mesh.transform.parent = nodoorMeshParent;
nodoorMeshs.Add(mesh, area);
return;
}
// 애니메이션과 클릭 이벤트가 적용될 문짝 오브젝트
d = item.GetChild(0).GetChild(0);
d.parent = item.transform;
dir = item.GetChild(0).localScale.x > 0 ? 1 : -1;
angle = d.eulerAngles;
localPosition = d.localPosition;
defaultX = localPosition.x;
defaultY = angle.y;
item.UpdateAsObservable()
.Where(condition => isMoving)
.Subscribe(_ =>
{
if (currentTime > animationTime)
{
isMoving = false;
currentTime = 0;
}
else
{
currentTime += Time.deltaTime;
angle.y = Mathf.Lerp(startPos, endPos, currentTime / animationTime);
d.eulerAngles = angle;
}
});
Destroy(item.GetComponent <BoxCollider>());
item = item.GetComponentInChildren <MeshCollider>().transform;
}
#endregion
// 오브젝트 클릭시
if (item.GetComponent <Collider>() == null)
{
item.gameObject.AddComponent <MeshCollider>();
}
item.OnMouseDownAsObservable()
.Where(_ => !EventSystem.current.IsPointerOverGameObject())
.Subscribe(_ =>
{
if (selectedObject == null || selectedObject != itemObject)
{
// 처음 클릭시
if (!selectable)
{
return;
}
else
{
Select(itemObject, type);
}
}
else if (selectedObject == itemObject)
{
// 두번째 클릭시
switch (type)
{
case DecorateType.Furniture:
if (!selectable)
{
SetFurniture();
}
else
{
Cancel();
}
break;
case DecorateType.Door:
// 문 열기/닫기
isMoving = true;
if (!isOpen)
{
isOpen = true;
if (item.parent.name == "SwingDoor(Clone)")
{
startPos = defaultY;
endPos = defaultY + 90 * dir;
}
}
else
{
isOpen = false;
if (item.parent.name == "SwingDoor(Clone)")
{
startPos = defaultY + 90 * dir;
endPos = defaultY;
}
}
break;
default:
if (!selectable)
{
return;
}
// 다른 경우에는 선택취소
Cancel();
break;
}
}
}).AddTo(this);
}
public void Start()
{
dmcHolder = GameObject.Find ("dmcHolder").transform;
stlHolder = GameObject.Find ("stlHolder").transform;
jobHolder = GameObject.Find ("jobHolder").transform;
gcdHolder = GameObject.Find("gcdHolder").transform;
var tbSpace = 20;
var tbWidth = InspectorT.TopToolbarStrings.Length * 120;
GetComponent<InspectorT>().MainRect = new Rect(2, 0, tbWidth, 80);
GetComponent<InspectorR>().MainRect = new Rect(Screen.width - 255, tbSpace, 250, 570);
GetComponent<InspectorL>().MainRect = new Rect(5, tbSpace, 250, 570);
windowStyle.fontSize = 50;
MM = GameObject.Find("MESH").GetComponent<MakeMesh>();
MM.material = stlMat;
MM.Begin();
}
public static List <List <Vector2> > GetMainLineData(Vector2[] line, float width)
{
return(MakeMesh.GetMainLineData(line, width));
}
