294 lines
12 KiB
C#
294 lines
12 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using ConsoleLSystem;
|
|
using System;
|
|
|
|
|
|
|
|
abstract public class TurtleLSystemEnvironment : TurtleLSystem {
|
|
|
|
public Environment environment;
|
|
// private LSystemEvaluator evaluator = null;
|
|
// private float nextStep;
|
|
public sbyte shadowStrength;
|
|
public int lookForLightAngle = 35;
|
|
public float lookForLightLength = 2.0f;
|
|
|
|
public Matrix4x4 lightDirection(Matrix4x4 transformation, Matrix4x4 resultTransformation, GameObject shape, LSystemNode node)
|
|
{
|
|
int minShadow = 10000;
|
|
Matrix4x4 bestTransformation = transformation;
|
|
int maxShadowTries = 20;
|
|
int shadowRotate = 360/20;
|
|
int shadowStrength_ = 0;
|
|
bool clearShape = false;
|
|
if(shape == null)
|
|
{
|
|
clearShape = true;
|
|
shape = new GameObject("ShadowConeShape");
|
|
}
|
|
GameObject instance;
|
|
Matrix4x4 new_transformation = transformation;
|
|
foreach (GameObject gameObject in GameObject.FindGameObjectsWithTag("ShadowCone")) {
|
|
DestroyImmediate(gameObject);
|
|
}
|
|
Matrix4x4 objectTransformation = (transformation*resultTransformation);
|
|
int nr_shadow_str = 1;
|
|
//---------------------miejsce-na-zadanie-3.4--------------------------------------//
|
|
|
|
int suma = 0;
|
|
int count = 0;
|
|
|
|
for (float x = -lookForLightLength; x < lookForLightLength; x += 0.5f)
|
|
{
|
|
for (float y = 0; y < lookForLightLength; y += 0.5f)
|
|
{
|
|
for (float z = -lookForLightLength; z < lookForLightLength; z += 0.5f)
|
|
{
|
|
Matrix4x4 nt = objectTransformation * Matrix4x4.Translate(new Vector3(x, y, z));
|
|
suma += environment.shadowStrength(nt.ExtractPosition());
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
//nr_shadow_str = environment.shadowStrength(transform.position);
|
|
//nr_shadow_str = suma / count;
|
|
|
|
//---------------------miejsce-na-zadanie-3.4-koniec-------------------------------//
|
|
if(environment.sendShadowToLSystem)
|
|
{
|
|
//---------------------miejsce-na-zadanie-3.5--------------------------------------//
|
|
|
|
if (node.literal.name == "P")
|
|
{
|
|
node.literal.values[1] += nr_shadow_str;
|
|
}
|
|
|
|
//node.literal.values[1] = nr_shadow_str;
|
|
//node.literal.values.args[1] = nr_shadow_str;
|
|
//Debug.Log("nodeliteral: " + node.literal.values);
|
|
|
|
//---------------------miejsce-na-zadanie-3.5-koniec------------------------------//
|
|
}
|
|
bestTransformation = transformation*resultTransformation;
|
|
if(environment.rotateTowardsLight)
|
|
{
|
|
minShadow = shadowStrength_;
|
|
if(shadowStrength_/nr_shadow_str > 5.0f)
|
|
{
|
|
shadowConeLimiter ++;
|
|
// transformation = Matrix4x4.Translate(gameObject.transform.position)*transformation;
|
|
for(int angle = 0;angle <= lookForLightAngle;angle+=10)
|
|
{
|
|
for(int i = 0; i < 360; i += shadowRotate)
|
|
{
|
|
shadowStrength_ = 0;
|
|
for(float length = 0.5f; length<lookForLightLength; length+=environment.voxelSize*0.5f)
|
|
{
|
|
new_transformation = (transformation*(resultTransformation*Matrix4x4.Rotate(Quaternion.Euler(0, i, 0))*Matrix4x4.Rotate(Quaternion.Euler(0, 0, angle))*Matrix4x4.Translate(new Vector3(0,length,0))));
|
|
shadowStrength_ += (int)environment.shadowStrength(new_transformation.ExtractPosition()+transformation.MultiplyPoint(shape.transform.position));
|
|
// if(shadowConeLimiter % 10 == 0)
|
|
// {
|
|
// instance = Instantiate(environment.shape);
|
|
// instance.name = "ShadowCone";
|
|
// instance.tag = "ShadowCone";
|
|
// instance.transform.position = new_transformation.ExtractPosition()+transformation.MultiplyPoint(shape.transform.position);
|
|
// instance.transform.rotation *= transformation.ExtractRotation();
|
|
// }
|
|
}
|
|
if(shadowStrength_ < minShadow)
|
|
{
|
|
|
|
minShadow = shadowStrength_;
|
|
bestTransformation = (transformation*(resultTransformation*Matrix4x4.Rotate(Quaternion.Euler(0, i, 0))*Matrix4x4.Rotate(Quaternion.Euler(0, 0, angle))));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/*if(minShadow > 220*lookForLightLength*2.0f)
|
|
{
|
|
bestTransformation = Matrix4x4.Translate(new Vector3(0,0,0));
|
|
}*/
|
|
}
|
|
/*if(clearShape)
|
|
{
|
|
DestroyImmediate(shape);
|
|
}*/
|
|
return bestTransformation;
|
|
}
|
|
public void evaluate() {
|
|
|
|
base.evaluate();
|
|
}
|
|
public void evaluateAndPresent() {
|
|
evaluate();
|
|
present();
|
|
// Debug.Log(evaluator.lSystemString.ToString().Length);
|
|
//x.name = "aaa";
|
|
|
|
//Instantiate(x,Matrix4x4.identity);
|
|
}
|
|
public void loadFile() {
|
|
// nextStep = Time.time;
|
|
// clearObjects();
|
|
var sr = new StreamReader(LSystemPath);
|
|
evaluator = LSystemFileParser.parseLSystem(sr);
|
|
sr.Close();
|
|
turtleInterpretation = new Dictionary<string, Func<float[], Tuple<GameObject, Matrix4x4>>>();
|
|
initLiteralInterpretation();
|
|
}
|
|
public void present() {
|
|
clearObjects();
|
|
createModelsRecursiveInEnviroment(evaluator.lSystemString, Matrix4x4.Translate(gameObject.transform.position/2.0f));//Matrix4x4.identity);
|
|
}
|
|
void refreshShadows()
|
|
{
|
|
environment.Reset();
|
|
foreach (GameObject gameObject in GameObject.FindGameObjectsWithTag("LSystemLiteral")) {
|
|
|
|
// if(!isParentThisGameObject(gameObject))
|
|
// {
|
|
environment.addShadow(gameObject.GetComponent<Transform>().position, shadowStrength);
|
|
// }
|
|
// else
|
|
// {
|
|
// if(isParentThisGameObject(gameObject, 2))
|
|
// {
|
|
// environment.addShadowPoint(gameObject.GetComponent<Transform>().position, 6);
|
|
// }
|
|
// }
|
|
}
|
|
}
|
|
bool isParentThisGameObject(GameObject gameObject, int depth = 3)
|
|
{
|
|
if(gameObject.transform.parent != null)
|
|
{
|
|
if(gameObject.transform.parent.gameObject == this.gameObject)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if(depth >= 0)
|
|
{
|
|
return isParentThisGameObject(gameObject.transform.parent.gameObject, depth-1);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
int objectCounter = 0;
|
|
int shadowConeLimiter = 0;
|
|
public int childrenCount(LSystemNode node, int depth = 3)
|
|
{
|
|
int c = 0;
|
|
if(node.children.Count > 0)
|
|
{
|
|
c += node.children.Count;
|
|
if(depth > 0)
|
|
{
|
|
foreach(LSystemNode child in node.children)
|
|
{
|
|
c+= childrenCount(child, depth - 1);
|
|
}
|
|
}
|
|
}
|
|
return c;
|
|
}
|
|
public void createModelsRecursiveInEnviroment(LSystemNode node, Matrix4x4 transformation, int depth = 0)
|
|
{
|
|
// transformation *= Matrix4x4.Translate(gameObject.transform.position);
|
|
while (node != null && objectCounter < 25000) {
|
|
Matrix4x4 new_transformation=transformation;
|
|
Func<float[], Tuple<GameObject, Matrix4x4>> interpretation;
|
|
var name = node.literal.name;
|
|
if (turtleInterpretation.TryGetValue(name, out interpretation) || turtleInterpretation.TryGetValue("*.*", out interpretation)) {
|
|
var result = interpretation(node.literal.values);
|
|
//Debug.Log("D: "+node.literal);
|
|
new_transformation = new_transformation*Matrix4x4.Rotate(Quaternion.Euler(UnityEngine.Random.Range(-0.5f, 0.5f), UnityEngine.Random.Range(-0.5f, 0.5f), UnityEngine.Random.Range(-0.5f, 0.5f)));
|
|
//new_transformation = lightDirection(new_transformation, result.Item2, result.Item1, node);
|
|
|
|
if(new_transformation == Matrix4x4.Translate(new Vector3(0,0,0)) && environment.cutBranchesWithMaxShadow)
|
|
{
|
|
Debug.Log(" children "+node.children.Count);
|
|
// node.literal.
|
|
if(childrenCount(node) < 5)
|
|
{
|
|
LSystemNode destroyNode = node;
|
|
if(destroyNode.parent != null)
|
|
{
|
|
destroyNode.parent.children.Remove(node);
|
|
if(destroyNode.parent.mainChild == null)
|
|
{
|
|
destroyNode.parent.mainChild = destroyNode.parent.children[0];
|
|
}
|
|
node = node.mainChild;
|
|
destroyNode = null;
|
|
// DestroyImmediate(instance);
|
|
objectCounter--;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (result.Item1 != null && new_transformation != Matrix4x4.Translate(new Vector3(0,0,0))) {
|
|
var instance = this.prepeareGameObject(name, result.Item1, new_transformation);
|
|
environment.addShadow(new_transformation.ExtractPosition()+transformation.MultiplyPoint(result.Item1.transform.position), (sbyte)(shadowStrength/8.0f));
|
|
}
|
|
|
|
environment.addShadow(new_transformation.ExtractPosition()+transformation.ExtractPosition(), (sbyte)(shadowStrength/8.0f));
|
|
environment.addShadow((new_transformation*Matrix4x4.Translate(new Vector3(0,1,0))).ExtractPosition()+transformation.ExtractPosition(), (sbyte)(shadowStrength/8.0f));
|
|
//remove scale, rather unnecesary
|
|
new_transformation = new_transformation * Matrix4x4.Scale(result.Item2.ExtractScale()).inverse;
|
|
}
|
|
if(node != null)
|
|
{
|
|
List<ConsoleLSystem.LSystemNode> children_tmp = new List<ConsoleLSystem.LSystemNode>();
|
|
foreach (var child in node.children)
|
|
{
|
|
children_tmp.Add(child);
|
|
}
|
|
foreach (var child in children_tmp)
|
|
{
|
|
if(child != null)
|
|
{
|
|
createModelsRecursiveInEnviroment(child, new_transformation, depth+1);
|
|
}
|
|
}
|
|
node = node.mainChild;
|
|
}
|
|
transformation = new_transformation;
|
|
}
|
|
|
|
}
|
|
|
|
private void clearObjects() {
|
|
//var objects = Resources.FindObjectsOfTypeAll<GameObject>().Where(obj => obj.name == "Name");
|
|
// foreach (GameObject gameObject in GameObject.FindGameObjectsWithTag("LSystemLiteral")) {
|
|
// DestroyImmediate(gameObject);
|
|
//
|
|
// }
|
|
objectCounter = 0;
|
|
int removed = 1;
|
|
while (removed > 0)
|
|
{
|
|
removed = 0;
|
|
foreach (Transform child in this.gameObject.transform) {
|
|
// environment.addShadow(gameObject.GetComponent<Transform>().position, (sbyte)-shadowStrength);
|
|
if(child.gameObject.tag == "LSystemLiteral")
|
|
{
|
|
DestroyImmediate(child.gameObject);
|
|
}
|
|
removed ++;
|
|
// GameObject.Destroy(child.gameObject);
|
|
}
|
|
|
|
}
|
|
refreshShadows();
|
|
// gameObjects = new List<GameObject>();
|
|
}
|
|
|
|
}
|