近期的一些进展ww

刚取得一些进展于是丢上来www还在制作中。

大概是一个渲染树的东西，不过也不全是w

上面的图大概是“进化过程”。前面的没什么好说的，主要说下Tree3（单说树枝的绘制方法，不讨论这个分形结构有多丑）：

它是这样构成的：

首先，把整个树枝分为几段，每一段是一个小“圆柱”（会有各种扭曲但是一定对应着圆形的截面）。在这里我把它分成了10段，圆形截面用六边形近似。

这根树枝的长度是固定的。根据这个长度求得每段的长度，先把每段抽象成一条线段，那么整个树枝就是一条折线。

每段的粗细程度自底向上减小，并带一点噪波（我把根部那一段做了加粗处理）。

长度固定。然后是旋转（生长方向）：

产生两个PerlinNoise，简记为noiseA和noiseP。

生长方向在前一段的基础上，做如下操作：

　　1）　先确定转轴：旋转轴以垂直于前一段生长方向的单位向量为基础（tangent），绕前一段生长方向旋转noiseP度。

　　2）　这一段的生长方向就是前一段的生长方向绕上一步确定的转轴旋转noiseA度。

大概就是这样，之后考虑加入重力和“径向扭曲”来营造真实感。当然还是先把分形结构改一下www

在研究了一会SpeedTree之后改的这些。不得不说学到了好多东西w

（植物在微重力环境下的生长： http://global.jaxa.jp/article/special/kibo/takahashi_e.html）

下面是代码（用Unity写的，为了之后各种东西写着也方便，想做一个小demo）：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Assets.FractalSystemCore.NodeInherits
{
public class TreeSplineNode
{
public Vector3 positionLocal = Vector3.zero;
public Quaternion rotationGlobal = Quaternion.identity;
public Vector3 tangentGlobal = Vector3.zero;
public float radius;
}

public enum BranchType
{
Trank,
Branch,
Root,
Leaves
}

//这里所有旋转为Global，位置为local。
class TreeVer3_CycWithSpline : FractalSystemNode
{
public int circleFragments = 6, nodes = 10;
public float radiusRate = 0.025f, height = 1.0f;

List<TreeSplineNode> spline = new List<TreeSplineNode>();

BranchType branchType = BranchType.Trank;

#region 形态处理函数

public void UpdateSpline()
{
int i = 0;

float startRadius, endRadius;
startRadius = radiusRate * growRate;

if(branchType == BranchType.Leaves)
{
return;
}
if(branchType == BranchType.Trank)
{
endRadius = startRadius * 0.15f;
}
else
{
endRadius = startRadius * 0.02f;
}

Vector3 startPos = centerPos;
Quaternion q = rotation;
float lengthStep = height * growRate / (spline.Count);

/*
在样条线上加一个PerlinNoise，两层（一层是幅度一层是相位）

转轴旋转平面垂直于上一个节点的生长方向，从0开始旋转noiseP度；
然后绕转轴旋转noiseA度。
*/

int noiseStep = spline.Count / 4;
float noiseAmpl = 8;//(height * growRate) / 6.0;

float[] noiseA = MathCore.PerlinNoise(spline.Count, noiseStep, noiseAmpl, 0);
float[] noiseP = MathCore.PerlinNoise(spline.Count, noiseStep, 180, 0);//相位先设定为2pi

//样条线
//第一个点和当前node的数据一致
spline[i].positionLocal = centerPos;
spline[i].rotationGlobal = rotation;
spline[i].tangentGlobal = (rotation * new Vector3(1, 0, 0));//假定切线在x轴
spline[i].radius = startRadius;

//如果是主干，根部加粗
if(branchType == BranchType.Trank)
{
spline[i].radius *= 2.0f;
}

for (i = 1; i < spline.Count; i++)
{
//位置是由上一个node的生长方向决定的
spline[i].positionLocal = spline[i - 1].positionLocal + spline[i - 1].rotationGlobal * new Vector3(0, lengthStep, 0);

//当前旋转方向由噪声决定
//先让这个节点的方向和上一个节点的方向保持一致
spline[i].rotationGlobal = spline[i - 1].rotationGlobal;
spline[i].tangentGlobal = spline[i - 1].tangentGlobal;

//再处理旋转
//转轴
Vector3 rotateAxis = Quaternion.AngleAxis(noiseP[i], spline[i - 1].rotationGlobal * new Vector3(0, lengthStep, 0)) * spline[i - 1].tangentGlobal;
rotateAxis.Normalize();

//旋转
Quaternion quaternion = Quaternion.AngleAxis(noiseA[i], rotateAxis);
spline[i].rotationGlobal = quaternion * spline[i].rotationGlobal;
spline[i].tangentGlobal = quaternion * spline[i].tangentGlobal;

//处理当前结点截面的大小
spline[i].radius = ((endRadius - startRadius) * (i / ((float)spline.Count)) + startRadius) * Random.Range(0.9f, 1.1f);
}
}

#endregion

public override void Express(
Vector3[] vertices,
ref int verticesCount,
int[] indices,
ref int indicesCount,
Vector3[] normals,
ref int normalsCount,
Vector2[] uvs,
ref int uvsCount,
Vector2[] uv2s,
ref int uv2sCount,
Vector4[] tangents,
ref int tangentsCount,
ref FractalRenderState state
)
{
/*

按圆柱表面坐标系上点的坐标给点标号。圆为横轴，高为纵轴。

顶点（x,y）坐标：
rad = x * (2f * Mathf.PI / circleFragments);
Vertex =        (cos(rad) * radius, y * heightStep, sin(rad) * radius);

顶点（x,y）法线：
rad = x * (2f * Mathf.PI / circleFragments);
Normal =        (cos(rad), 0, sin(rad))

构成整个子结构的面：
for(x = 0; x < circleFragments - 1; x++)
for(y = 0; y < heightFragments - 1; y++)
Indices =               ( x, y ) ( x + 1, y + 1 ) ( x + 1, y ); ( x, y ) ( x , y + 1 ) ( x + 1, y + 1 )

不封口。反正也看不见（
*/

//int vert = 0, x, y;
//float radius = radiusRate * growRate, heightStep = height * growRate / (spline.Count);
//float rad;

//添加样条线节点
for(int i = 0; i < nodes; i++)
{
spline.Add(new TreeSplineNode());
}

//先处理样条线的形态
UpdateSpline();
//施加重力
//施加径向扭曲力

//绘制
int vert = 0, x, index;
float rad, radiusReal;

#region Vertices & Normals

for (index = 0; index < spline.Count; index++)
{
for (x = 0; x < circleFragments; x++)
{
radiusReal = spline[index].radius * Random.Range(0.9f, 1.1f);

rad = x * (2f * Mathf.PI / circleFragments);

vertices[verticesCount + (x + index * circleFragments)] =
state.centerPos + (spline[index].rotationGlobal * new Vector3(
Mathf.Cos(rad) * radiusReal,
0,
Mathf.Sin(rad) * radiusReal)) + spline[index].positionLocal;

normals[verticesCount + (x + index * circleFragments)] = spline[index].rotationGlobal * new Vector3(
Mathf.Cos(rad),
0,
Mathf.Sin(rad));

vert++;
}
}

#endregion

#region Indices

for (x = 0; x < circleFragments - 1; x++)
for (index = 0; index < (spline.Count - 1); index++)
{
//Indices = ( x, y ) ( x + 1, y + 1 ) ( x + 1, y ); ( x, y ) ( x , y + 1 ) ( x + 1, y + 1 )
indices[indicesCount++] = verticesCount + (x + index * circleFragments);
indices[indicesCount++] = verticesCount + (x + 1 + (index + 1) * circleFragments);
indices[indicesCount++] = verticesCount + (x + 1 + index * circleFragments);
indices[indicesCount++] = verticesCount + (x + index * circleFragments);
indices[indicesCount++] = verticesCount + (x + (index + 1) * circleFragments);
indices[indicesCount++] = verticesCount + (x + 1 + (index + 1) * circleFragments);
}

for (index = 0; index < (spline.Count - 1); index++)
{
//Indices = ( x, y ) ( x + 1, y + 1 ) ( x + 1, y ); ( x, y ) ( x , y + 1 ) ( x + 1, y + 1 )
indices[indicesCount++] = verticesCount + (x + index * circleFragments);
indices[indicesCount++] = verticesCount + (0 + (index + 1) * circleFragments);
indices[indicesCount++] = verticesCount + (0 + index * circleFragments);
indices[indicesCount++] = verticesCount + (x + index * circleFragments);
indices[indicesCount++] = verticesCount + (x + (index + 1) * circleFragments);
indices[indicesCount++] = verticesCount + (0 + (index + 1) * circleFragments);
}

#endregion

verticesCount += vert;
normalsCount += vert;
//indicesCount已经在上面加过了

state.centerPos += spline[spline.Count - 1].positionLocal;
state.rotation = Quaternion.identity;
}

static float panStepStart = 60f;
static float panStepStop = 120f;
static float panOffsetMax = 60f;
static float tiltStart = 20f;
static float tiltEnd = 70f;

/*
生长率控制，在这里生长率为和这个树枝与主干的夹角（tilt）线性相关的一个量和一个加性高斯噪声叠加而成。start与end定义出这个线性相关量（与tilt相对应），noiseRad定义出噪声的方差（功率）。
*/
static float growRateStart = 0.6f;
static float growRateEnd = 0.8f;
static float growNoiseRad = 0.04f;

public override void generateChildren()
{
float nowDeg = 0f, offset = Random.Range(0f, panOffsetMax);

while (nowDeg < 360.0f)
{
nowDeg += Random.Range(panStepStart, panStepStop);
float tilt = Random.Range(tiltStart, tiltEnd);

FractalSystemNode node = new TreeVer3_CycWithSpline();
node.rotation = Quaternion.AngleAxis(tilt,
Quaternion.AngleAxis(offset, Vector3.up) * Quaternion.AngleAxis(nowDeg, Vector3.up) * new Vector3(0, 0, 1)) * rotation;

node.centerPos = new Vector3(0, 0, 0);

//与旋转角度的余弦线性相关
node.growRate = growRate * (((Mathf.Cos(tiltStart / 180.0f * Mathf.PI) - Mathf.Cos(tilt / 180.0f * Mathf.PI)) / (Mathf.Cos(tiltStart / 180.0f * Mathf.PI) - Mathf.Cos(tiltEnd / 180.0f * Mathf.PI))) *
((growRateEnd) - (growRateStart)) + growRateStart + Random.Range(-growNoiseRad, growNoiseRad));

node.globalRotation = node.rotation;// * globalRotation;
node.centerPos = node.centerPos + globalPos;

//朝向下方的惩罚（得不到光照etc.）
Vector3 final = node.globalRotation * Vector3.up;
if (final.y < 0.1f)
{
float factor = (0.1f - final.y) / 1.1f;
node.growRate *= ((factor - 1) * (factor - 1)) * 0.4f + 0.6f;
}

child.Add(node);
}
}
}
}

最新的www