Actor.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using Sharp3D.Math.Core;

using Sharp3D.Math.Geometry3D;

using System.IO;

using System.Xml;

using System.Xml.Serialization;

using HelpTools;

namespace Editor

{

public class IFile

{

}

// 全局唯一值，用来记录其他物品

public struct GIID

{

public GIID(int id, GIIDMng giidmng)

{

m_id = id;

m_giid_mng = giidmng;

}

public GIID(int id) { m_id = id; m_giid_mng = null; }

// 获得唯一值

public int value { get { return m_id; } }

// 所记录的唯一值

int m_id;

public override int GetHashCode()

{

return base.GetHashCode();

}

public override bool Equals(object obj)

{

if (obj is GIID)

{

return this.m_id == ((GIID)obj).m_id;

}

return false;

}

// 所记录的唯一值

public static bool operator ==(GIID giid1, GIID giid2)

{

return giid1.m_id == giid2.m_id;

}

public static bool operator !=(GIID giid1, GIID giid2)

{

return !(giid1 == giid2);

}

public override string ToString()

{

return m_giid_mng.getIDString(this);

}

public void Parse(string id_string)

{

m_giid_mng.setIDString(this, id_string);

}

GIIDMng m_giid_mng;

}

// 全局唯一值管理器

// 没有完成

public class GIIDMng

{

public GIIDMng()

{

}

// 生成一个全局唯一值

public GIID getGIID()

{

GIID giid = new GIID(m_id_acc++, this);

m_map[giid] = Guid.NewGuid().ToString();

return giid;

}

public bool getGIID(string id_string, out GIID giid)

{

foreach (KeyValuePair<GIID, string> pair in m_map)

{

if (pair.Value == id_string)

{

giid = pair.Key;

return true;

}

giid = new GIID();

return false;

}

public void setIDString(GIID id, string id_string)

{

m_map[id] = id_string;

}

public string getIDString(GIID id)

{

return m_map[id];

}

// 删除一个全局唯一值

public void removeGIID(GIID id)

{

if (m_map.ContainsKey(id))

{

m_map.Remove(id);

}

public void Clear()

{

m_map.Clear();

//m_id_acc = 0;

}

int m_id_acc = 0;

Dictionary<GIID, string> m_map = new Dictionary<GIID, string>();

// 地图编辑器社区使用，其他慎用！

public void SetNextGiid(int next)

{

if (next <= m_id_acc)

return;

else

m_id_acc = next;

}

// 物品memento，用物品属性列表构建

public class ActorMemento : IMemento

{

public Dictionary<String, String> m_property_dic = new Dictionary<string, string>();

}

public enum ActorFlag

{

UNDELETEABLE = 0x01, //是否可以删除

UNEDITABLE = 0x02, //是否可以编辑

UNSELECTABLE = 0x04, //是否可以选择

UNMOVEABLE = 0x08, //是否可以移动

UNSERIALIZABLE = 0x10,//是否可以序列化

UNCOPYPASTABLE = 0x20,//是否可以复制粘贴

}

public interface ISelectableObject

{

// 鼠标悬浮

bool mouseHover(Rect<int> rect, IView view);

// 鼠标选择

bool mouseSelect(Rect<int> rect, IView view);

}

public interface ITransformableObject

{

// 移动物品

void move(Vector3F v);

// 移动到指定位置

void moveTo(Vector3F pos);

// 旋转

void rotate(Vector3F pos, Vector3F axis, float angle);

// 缩放

void scale(Vector3F scale_var);

// 对齐

void align(IActor dst_actor, bool x_axis, bool y_axis, bool z_axis);

}

//物品类型枚举,炫舞1编辑器从炫舞2修改而来，遗留了很多无用或者不合适的定义和数据结构，这里重新定义一个枚举是为了减少之前的杂乱和引进的错误

public enum ACTOR_TYPE

{

AT_DML,

AT_CHR,

AT_ACTOR,

AT_NEWACTOR,

AT_SPE,

AT_SOUND,

AT_AINODE,

AT_LIGHT,

AT_GROUP,

AT_END

}

// 物品接口类

public interface IActor : ISelectableObject, ITransformableObject, IDisposable

{

// 复制

IActor clone(IEditItem edititem);

// 获得子物品容器,如果没有子物品容器返回null

IActorLayerMng getActorBuffer();

// 2D的矩形位置

Rect<int> rect { get; set; }

//scale

Vector3F Scale { get; }

// 3D位置矩阵

Matrix4F locationmat { get; set; }

// 包围盒

AxisAlignedBox aabb { get; set; }

// 中心

Vector3F center { get; set; }

// 是否隐藏

bool hide { get; set; }

// 是否冻结

bool freeze { get; set; }

// 是否显示名称

bool canDisplayName { get; set; }

// 所属物品层

IActorLayerMng parentLayer { get; set; }

// 父物品

IActor parent { get; set; }

// 物品名称

string name { get; set; }

//是否生成阴影

bool genlightmap { get; set; }

//是否投射（实时）阴影

bool castshadow { get; set; }

//获得标志

int flag { get; }

// 获得设置memento

IMemento getMemento(int mode);

void setMemento(IMemento mem);

// 更新

void update(int t);

void UpdateCpuSkin(float t);

// 绘制

void render(int t, ClientBridge.ClientRenderSys rendersys);

// 绘制包围盒

void renderAABB(int t, ClientBridge.ClientRenderSys rendersys, Color color);

// 绘制坐标轴

void renderCoordinate(int t, ClientBridge.ClientRenderSys rendersys);

// 绘制圆

void renderCircles(int t, ClientBridge.ClientRenderSys rendersys);

// 全局唯一ID，主要用来保存链接的内容

GIID giid { get; }

// 物品移动控制轴对应的ID

List<GIID> giid_move { get; }

// 物品旋转控制圆对应的ID

List<GIID> giid_rotate { get; }

// 获得key/value的列表

IDictionary<String, String> getPropertyList();

// 更改key所对应的value

void notifyPropertyChange(String key, String value);

// edititem用来获得可能需要的信息

// 读取/保存物品信息到xml节点中

bool serialize(System.Xml.XmlNode xmlnode, IEditItem edititem, bool load, bool clipboard);

// 读取/保存物品信息到文件中

bool serialize(IFile file, IEditItem edititem, bool load);

// 保存物品

bool serialize(BinaryWriter binWriter);

// 读取物品

bool serialize(BinaryReader binReader, IEditItem edititem);

// 移动物品

new void move(Vector3F v);

// 移动到指定位置

new void moveTo(Vector3F pos);

// 旋转

new void rotate(Vector3F pos, Vector3F axis, float angle);

// 缩放

new void scale(Vector3F scale_var);

void scaleForPar(Vector3F scale_var);

// 设置物品位置，并更新物品包围盒

void updateLocationAABB();

// 将物品加入到硬件选择

void pushHardwareSelect(ClientBridge.ClientRenderSys rendersys);

// 将线模型加入到硬件选择

void pushLineHardwareSelect(ClientBridge.ClientRenderSys rendersys);

// 将移动控制轴加入到硬件选择

void pushHardwareSelect_Move(ClientBridge.ClientRenderSys rendersys);

// 将旋转控制圆加入到硬件选择

void pushHardwareSelect_Rotate(ClientBridge.ClientRenderSys rendersys);

// 得到物品类别字符串

string getActorTypestr();

//父物品层Hide操作回调

void notifyLayerHide(bool isHide);

//父物品层Freeze操作回调

void notifyLayerFreeze(bool isFreeze);

//获取物体是否可见

bool isVisible();

//得到物品类型

ACTOR_TYPE GetActorType();

//删除一个模型时，会从管理器中拿走，在从管理器拿走之前做一些必要的重置操作

//目前用到该地方的是宝宝和坐骑绑定，在释放坐骑时要将和宝宝的绑定关系重置

void DoBeforeDel();

}

// 物品的实现辅助基类，用来实现若干默认物品的接口，方便物品接口的实现

// 实现IActor的类不是必须要继承这个类！

public class ActorBase : IXmlSerial

{

protected GIID m_giid = new GIID();

List<GIID> m_move_giid = new List<GIID>(); // 为物品移动控制轴提供六个ID，以控制移动方向

List<GIID> m_rotate_giid = new List<GIID>(); // 为物品旋转控制圆提供3个ID，以控制旋转方向， fixme:目前绕三个轴旋转

Rect<int> m_rect = new Rect<int>(); // 2d矩形位置，界面编辑器用

bool m_hide = false; // 是否隐藏

bool m_freeze = false; // 是否冻结

protected Dictionary<String, String> m_property_dic = new Dictionary<string, string>(); // 属性列表

Matrix4F m_locationmat = Matrix4F.Identity; // 3d位置矩阵

protected AxisAlignedBox m_aabb = new AxisAlignedBox(); // 包围盒

protected Vector3F m_center = new Vector3F(); // 物品中心（移动、旋转轴），暂时为包围盒中心，在更新包围盒的同时更新物品中心

IActor m_parent = null; // 物品属于哪个父物品（Group、Prefeb）

public virtual IActorLayerMng getActorBuffer() { return null; }

public virtual ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_END;

}

public virtual void DoBeforeDel()

{

}

public ActorBase()

{

}

virtual public Rect<int> rect

{

get { return m_rect; }

set { m_rect = value; }

}

virtual public int flag

{

get { return 0; }

}

virtual public bool hide

{

get { return m_hide; }

set

{

m_hide = value;

}

virtual public bool freeze

{

get { return m_freeze; }

set

{

m_freeze = value;

}

virtual public IActor parent

{

get { return m_parent; }

set { m_parent = value; }

}

/// <summary>

/// 物品所属的层

/// </summary>

[XmlIgnore]

virtual public IActorLayerMng parentLayer

{

get { return m_parent_layer; }

set { m_parent_layer = value; }

}

IActorLayerMng m_parent_layer = null;

protected QuaternionF m_quat = QuaternionF.Identity;

virtual public string name

{

get { return ""; }

set { AssertUtil.confirm(this is PrefebActor); }

}

/// <summary>

/// 是否显示名称

/// </summary>

virtual public bool canDisplayName

{

get { return m_canDisplayName; }

set { m_canDisplayName = value; }

}

bool m_canDisplayName = true;

virtual public Matrix4F locationmat

{

get { return m_locationmat; }

set

{

m_locationmat = value;

updateLocationAABB();

}

virtual public Vector3F Scale

{

get

{

return m_scale;

}

protected Vector3F m_scale = new Vector3F(1, 1, 1);

// 获得物品Memento

virtual public IMemento getMemento(int mode)

{

ActorMemento mem = new ActorMemento();

foreach (KeyValuePair<string, string> kv in m_property_dic)

{

mem.m_property_dic.Add(kv.Key, kv.Value);

}

return mem;

}

// 设置物品Memento

virtual public void setMemento(IMemento mem)

{

ActorMemento actormem = (ActorMemento)mem;

foreach (KeyValuePair<string, string> kv in actormem.m_property_dic)

{

notifyPropertyChange(kv.Key, kv.Value);

}

// 移动物品

virtual public void move(Vector3F v)

{

// // 移动Group中的子物品

// IActorLayerMng sublayer = getActorBuffer();

// if (sublayer != null)

// {

// foreach (IActor actor in sublayer.getOrgBuffer())

// {

// actor.move(v);

// }

// else // 非Group物品

// {

// Matrix4F matrixmove = TransformationF.Translation(v);

// notifyPropertyChange("LocationMat", (matrixmove * locationmat).ToString());

// }

// 移动Group中的子物品

IActorLayerMng sublayer = getActorBuffer();

if (sublayer != null)

{

foreach (IActor actor in sublayer.getOrgBuffer())

{

actor.move(v);

}

Matrix4F matrixmove = TransformationF.Translation(v);

notifyPropertyChange("LocationMat", (matrixmove * locationmat).ToString());

}

virtual public void Attach(ClientBridge.SceneBase scene)

{

}

virtual public void Detach(ClientBridge.SceneBase scene)

{

}

virtual public void SetLod(ClientBridge.LOD_LEVEL lod)

{

}

// 将物品移动到某位置

virtual public void moveTo(Vector3F pos)

{

// // 移动Group中的子物品到某位置

// IActorLayerMng sublayer = getActorBuffer();

// if (sublayer != null)

// {

// foreach (IActor actor in sublayer.getOrgBuffer())

// {

// //Vector3F minpos = GActorHelper.getMinPos(sublayer.getOrgBuffer());

// //Vector3F possub = new Vector3F(pos.X + (actor.aabb.Min.X - minpos.X),

// // pos.Y + (actor.aabb.Min.Y - minpos.Y),

// // pos.Z + (actor.aabb.Min.Z - minpos.Z));

// Vector3F possub = new Vector3F(pos.X + (actor.locationmat.M14 - locationmat.M14),

// pos.Y + (actor.locationmat.M24 - locationmat.M24),

// pos.Z + (actor.locationmat.M34 - locationmat.M34));

// actor.moveTo(possub);

// }

// //else // fixme:

// {

// Matrix4F matrixmove = TransformationF.Translation(pos);

// notifyPropertyChange("LocationMat", (matrixmove * Matrix4F.Identity).ToString());

// }

// 移动Group中的子物品到某位置

IActorLayerMng sublayer = getActorBuffer();

if (sublayer != null)

{

foreach (IActor actor in sublayer.getOrgBuffer())

{

//Vector3F minpos = GActorHelper.getMinPos(sublayer.getOrgBuffer());

//Vector3F possub = new Vector3F(pos.X + (actor.aabb.Min.X - minpos.X),

// pos.Y + (actor.aabb.Min.Y - minpos.Y),

// pos.Z + (actor.aabb.Min.Z - minpos.Z));

Vector3F possub = new Vector3F(pos.X + (actor.locationmat.M14 - locationmat.M14),

pos.Y + (actor.locationmat.M24 - locationmat.M24),

pos.Z + (actor.locationmat.M34 - locationmat.M34));

actor.moveTo(possub);

}

Matrix4F matrixmove = TransformationF.Translation(pos);

Matrix4F locatmat = new Matrix4F(locationmat);

locatmat.M14 = 0;

locatmat.M24 = 0;

locatmat.M34 = 0;

notifyPropertyChange("LocationMat", (matrixmove * locatmat).ToString());

}

virtual protected bool CanTransform()

{

return true;

}

public virtual void UpdateCpuSkin(float t)

{

}

virtual public void align(IActor dst_actor, bool x_axis, bool y_axis, bool z_axis)

{

if (CanTransform() && dst_actor != null)

{

Vector3F pos = new Vector3F((x_axis ? dst_actor.locationmat.M14 : locationmat.M14), (y_axis ? dst_actor.locationmat.M24 : locationmat.M24), (z_axis ? dst_actor.locationmat.M34 : locationmat.M34));

moveTo(pos);

}

private void set_world_location(Vector3F wloc)

{

Matrix4F matrixmove = TransformationF.Translation(wloc);

Matrix4F locatmat = new Matrix4F(locationmat);

locatmat.M14 = 0;

locatmat.M24 = 0;

locatmat.M34 = 0;

notifyPropertyChange("LocationMat", (matrixmove * locatmat).ToString());

}

// 旋转物品

virtual public void rotate(Vector3F pos, Vector3F axis, float angle)

{

axis.Normalize();

QuaternionF quat = QuaternionF.FromAxisAngle(axis, angle);

m_quat = quat * m_quat;

m_quat.Normalize();

// Group

IActorLayerMng sublayer = getActorBuffer();

if (sublayer != null)

{

foreach (IActor actor in sublayer.getOrgBuffer())

{

Vector3F rotatecenter = pos;

GroupActor groupactor = actor.parent as GroupActor;

if (groupactor != null && groupactor.rotatemode == RotateMode.RM_SELF) // Group内物品绕自身轴旋转

{

rotatecenter = actor.center;

}

actor.rotate(rotatecenter, axis, angle);

}

Matrix4F matrixmove = TransformationF.Translation(-pos);

Matrix4F matrixrotate = TransformationF.RotationAxis(axis, angle);

Matrix4F matrixmoveback = TransformationF.Translation(pos);

notifyPropertyChange("LocationMat", (matrixmoveback * matrixrotate * matrixmove * locationmat).ToString());

Vector3F euler = Tool.QuaternionToEulerXYZ(m_quat);

m_euler.X = Tool.Rad2Deg(euler.X);

m_euler.Y = Tool.Rad2Deg(euler.Y);

m_euler.Z = Tool.Rad2Deg(euler.Z);

notifyPropertyChange("旋转角度", m_euler.ToString());

return;

}

// 缩放

private void scale(float x, float y, float z)

{

Vector3F center = new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34);

Matrix4F matrixmove = TransformationF.Translation(-center);

Matrix4F matrixscale = TransformationF.Scaling(x, y, z);

Matrix4F matrixmoveback = TransformationF.Translation(center);

notifyPropertyChange("LocationMat", (matrixmoveback * matrixscale * matrixmove * locationmat).ToString());

}

// 缩放

virtual public void scaleForPar(Vector3F scale_var)

{

if (CanTransform())

{

Vector3F new_scale = new Vector3F(scale_var.X * m_scale.X, scale_var.Y * m_scale.Y, scale_var.Z * m_scale.Z);

notifyPropertyChange("缩放比例", new_scale.ToString());

}

virtual public void scale(Vector3F scale_var)

{

m_scale = new Vector3F(scale_var.X * m_scale.X, scale_var.Y * m_scale.Y, scale_var.Z * m_scale.Z);

Vector3F center = new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34);

Matrix4F matrixmove = TransformationF.Translation(-center);

Matrix4F matrixscale = TransformationF.Scaling(scale_var.X, scale_var.Y, scale_var.Z);

Matrix4F matrixmoveback = TransformationF.Translation(center);

notifyPropertyChange("缩放比例", (matrixmoveback * matrixscale * matrixmove * locationmat).ToString());

}

private void rotate(Vector3F euler)

{

Vector3F r_euler = new Vector3F(Tool.Deg2Rad(euler.X), Tool.Deg2Rad(euler.Y), Tool.Deg2Rad(euler.Z));

m_quat = Tool.EulerXYZToQuaternion(r_euler);

m_quat.Normalize();

Matrix4F matrixscale = TransformationF.Scaling(m_scale);

Matrix4F matrixrotate = QuaternionF.QuaternionToMatrix(m_quat);

Matrix4F matrixmoveback = TransformationF.Translation(new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34));

notifyPropertyChange("LocationMat", (matrixmoveback * matrixscale * matrixrotate).ToString());

}

virtual public AxisAlignedBox aabb

{

get { return m_aabb; }

set

{

m_aabb = value;

// 更新物品中心

//m_center = new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34);

m_center = new Vector3F((m_aabb.Min.X + m_aabb.Max.X) / 2.0f, (m_aabb.Min.Y + m_aabb.Max.Y) / 2.0f, (m_aabb.Min.Z + m_aabb.Max.Z) / 2.0f);

}

virtual public Vector3F center

{

get { return m_center; }

set { m_center = value; }

}

virtual public void updateLocationAABB()

{

// 所有物品在更新位置时都需要更新其父物品的位置，放到基类

if (parent != null)

{

parent.updateLocationAABB();

}

public virtual void update(int t)

{

}

public virtual void render(int t, ClientBridge.ClientRenderSys rendersys)

{

}

// 绘制包围盒

public virtual void renderAABB(int t, ClientBridge.ClientRenderSys rendersys, Color color)

{

float[] c = { color.r, color.g, color.b, color.a };

Vector3F[] vetexs = aabb.ComputeVertices();

float[] points = new float[24];

for (int i = 0; i < 8; i++)

{

points[i * 3] = vetexs[i].X;

points[i * 3 + 1] = vetexs[i].Y;

points[i * 3 + 2] = vetexs[i].Z;

}

int[] indexs = { 0,1, 1,2, 2,3, 3,0,

4,5, 5,6, 6,7, 7,4,

0,4, 1,5, 2,6, 3,7

};

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexs, c, false);

}

// 将移动控制轴加入到硬件选择

virtual public void pushHardwareSelect_Move(ClientBridge.ClientRenderSys rendersys)

{

GroupActor ga = this as GroupActor;

if (ga != null && !ga.close)

{

ActorBuffer gab = getActorBuffer().getOrgBuffer();

foreach (IActor gasel in gab)

{

gasel.pushHardwareSelect_Move(rendersys);

}

float[] colorr = { 1, 0, 0, 1 };

float[] colorg = { 0, 1, 0, 1 };

float[] colorb = { 0, 0, 1, 1 };

float[] colorw = { 1, 1, 1, 1 };

float[] points = { center.X, center.Y, center.Z, // 0 o

center.X + 2.0f, center.Y, center.Z, // 1 x

center.X, center.Y + 2.0f, center.Z, // 2 y

center.X, center.Y,center.Z + 2.0f, // 3 z

center.X + 1.0f, center.Y, center.Z, // 4 x_h

center.X, center.Y +1.0f, center.Z, // 5 y_h

center.X, center.Y, center.Z + 1.0f, // 6 z_h

center.X+1.0f, center.Y+1.0f, center.Z, // 7 x_y

center.X+1.0f, center.Y, center.Z + 1.0f, // 8 x_z

center.X, center.Y+1.0f, center.Z + 1.0f // 9 y_z

};

int[] indexs_x = { 0, 1 }; // x轴索引

int[] indexs_y = { 0, 2 }; // y轴索引

int[] indexs_z = { 0, 3 }; // z轴索引

int[] indexs_xy = { 4, 7, 5 }; // xy夹角索引

int[] indexs_xz = { 4, 8, 6 }; // xz夹角索引

int[] indexs_yz = { 5, 9, 6 }; // yz夹角索引

rendersys.pushSelectID((uint)(m_move_giid[0].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_x, colorr, true);

rendersys.pushSelectID((uint)(m_move_giid[1].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_y, colorg, true);

rendersys.pushSelectID((uint)(m_move_giid[2].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_z, colorb, true);

rendersys.pushSelectID((uint)(m_move_giid[3].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xy, colorw, true);

rendersys.pushSelectID((uint)(m_move_giid[4].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xz, colorw, true);

rendersys.pushSelectID((uint)(m_move_giid[5].value));

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_yz, colorw, true);

return;

}

// 绘制移动控制轴

public virtual void renderCoordinate(int t, ClientBridge.ClientRenderSys rendersys)

{

float[] colorr = { 1, 0, 0, 1 };

float[] colorg = { 0, 1, 0, 1 };

float[] colorb = { 0, 0, 1, 1 };

float[] colorw = { 1, 1, 1, 1 };

float[] points = { center.X, center.Y, center.Z, // 0 o

center.X + 2.0f, center.Y, center.Z, // 1 x

center.X, center.Y + 2.0f, center.Z, // 2 y

center.X, center.Y,center.Z + 2.0f, // 3 z

center.X + 1.0f, center.Y, center.Z, // 4 x_h

center.X, center.Y +1.0f, center.Z, // 5 y_h

center.X, center.Y, center.Z + 1.0f, // 6 z_h

center.X+1.0f, center.Y+1.0f, center.Z, // 7 x_y

center.X+1.0f, center.Y, center.Z + 1.0f, // 8 x_z

center.X, center.Y+1.0f, center.Z + 1.0f // 9 y_z

};

int[] indexs_x = { 0, 1 }; // x轴索引

int[] indexs_y = { 0, 2 }; // y轴索引

int[] indexs_z = { 0, 3 }; // z轴索引

int[] indexs_xy = { 4, 7, 5 }; // xy夹角索引

int[] indexs_xz = { 4, 8, 6 }; // xz夹角索引

int[] indexs_yz = { 5, 9, 6 }; // yz夹角索引

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_x, colorr, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_y, colorg, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_z, colorb, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xy, colorw, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xz, colorw, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_yz, colorw, true);

}

// 将移动控制轴加入到硬件选择

virtual public void pushHardwareSelect_Rotate(ClientBridge.ClientRenderSys rendersys)

{

GroupActor ga = this as GroupActor;

if (ga != null && !ga.close)

{

ActorBuffer gab = getActorBuffer().getOrgBuffer();

foreach (IActor gasel in gab)

{

gasel.pushHardwareSelect_Rotate(rendersys);

}

List<uint> idlist = new List<uint>();

for (int i = 0; i < m_rotate_giid.Count; i++)

{

idlist.Add((uint)m_rotate_giid[i].value);

}

GActorHelper.drawRotateCircles(idlist, center, rendersys);

return;

}

// 绘制旋转控制圆

public virtual void renderCircles(int t, ClientBridge.ClientRenderSys rendersys)

{

GActorHelper.drawRotateCircles(null, center, rendersys);

}

/// <summary>

/// Xml序列化使用

/// </summary>

public Vector3F Euler

{

get { return m_euler; }

}

protected Vector3F m_euler = new Vector3F(0, 0, 0);

public Vector3F Trans

{

get { return m_trans; }

}

protected Vector3F m_trans = new Vector3F(0, 0, 0);

/// <summary>

/// 是否产生实时阴影

/// </summary>

virtual public bool castshadow

{

get { return m_castshadow; }

set { m_castshadow = value; }

}

bool m_castshadow = true;

/// <summary>

/// 是否物体生成阴影

/// </summary>

virtual public bool genlightmap

{

get { return m_genLightMap; }

set { m_genLightMap = value; }

}

bool m_genLightMap = true;

public GIID giid

{

get { return m_giid; }

private set { m_giid = value; }

}

public List<GIID> giid_move

{

get { return m_move_giid; }

}

public List<GIID> giid_rotate

{

get { return m_rotate_giid; }

}

// 得到物品属性列表

virtual public IDictionary<String, String> getPropertyList()

{

return m_property_dic;

}

virtual public void notifyPropertyChange(String key, String value)

{

string old_value = m_property_dic.ContainsKey(key) ? m_property_dic[key] : null;

m_property_dic[key] = value;

if (key == "LocationMat")

{

locationmat = Matrix4F.setMatrix(value);

}

else if (key == "Hide")

{

hide = bool.Parse(value);

}

else if (key == "Freeze")

{

freeze = bool.Parse(value);

}

else if (key == "产生阴影")

{

if (!bool.TryParse(value, out m_genLightMap))

{

return;

}

else if (key == "实时阴影")

{

if (!bool.TryParse(value, out m_castshadow))

{

return;

}

else if (key == "缩放比例")

{

Vector3F old_scale, new_scale;

try

{

old_scale = Vector3F.Parse(old_value);

new_scale = Vector3F.Parse(value);

}

catch

{

return;

}

if (old_scale.X != 0 && old_scale.Y != 0 && old_scale.Z != 0)

{

m_scale = new_scale;

scale(new_scale.X / old_scale.X, new_scale.Y / old_scale.Y, new_scale.Z / old_scale.Z);

}

else if (key == "世界坐标")

{

try

{

m_trans = Vector3F.Parse(value);

}

catch (System.Exception)

{

return;

}

set_world_location(m_trans);

}

else if (key == "旋转角度")

{

Vector3F euler = new Vector3F(0, 0, 0);

try { euler = Vector3F.Parse(value); }

catch (System.Exception) { return; }

if (!Tool.FloatCompare(euler.X, m_euler.X, 0.001f) ||

!Tool.FloatCompare(euler.Y, m_euler.Y, 0.001f) ||

!Tool.FloatCompare(euler.Z, m_euler.Z, 0.001f))

{

m_euler = euler;

rotate(m_euler);

}

insertValueToPropertyDic(key, value);

}

public virtual void insertValueToPropertyDic(string key, string value)

{

m_property_dic[key] = value;

}

public ActorBase(GIIDMng giidmng)

{

m_giid = giidmng.getGIID();

for (int i = 0; i < 6; i++)

{

m_move_giid.Add(giidmng.getGIID());

}

for (int i = 0; i < 3; i++)

{

m_rotate_giid.Add(giidmng.getGIID());

}

m_property_dic["Hide"] = hide.ToString();

m_property_dic["Freeze"] = freeze.ToString();

m_property_dic["产生阴影"] = m_genLightMap.ToString();

m_property_dic["实时阴影"] = m_castshadow.ToString();

m_property_dic["缩放比例"] = m_scale.ToString();

m_property_dic["世界坐标"] = m_trans.ToString();

m_property_dic["旋转角度"] = m_euler.ToString();

}

public bool serialize(IFile file, IEditItem edititem, bool load)

{

return true;

}

// 保存读取

public virtual bool serialize(System.Xml.XmlNode xmlnode, IEditItem edititem, bool load, bool clipboard)

{

if (load)

{

foreach (XmlNode childnode in xmlnode.ChildNodes)

{

if (childnode.Name != "Item")

{

m_property_dic[childnode.Name] = childnode.Value;

notifyPropertyChange(childnode.Name, childnode.InnerText);

}

else

{ //

IActor actor = GActorHelper.generateActorWithoutInfo(childnode.Attributes["type"].Value, edititem);

actor.serialize(childnode, edititem, load, clipboard);

getActorBuffer().getOrgBuffer().insert(actor);

}

else // save

{

foreach (KeyValuePair<string, string> kv in m_property_dic)

{

XmlNode node = xmlnode.OwnerDocument.CreateNode("element", kv.Key, "");

node.InnerText = kv.Value;

xmlnode.InsertAfter(node, xmlnode.LastChild);

}

if (this is GroupActor)

{

foreach (IActor subactor in getActorBuffer().getOrgBuffer())

{

XmlNode node = xmlnode.OwnerDocument.CreateNode("element", "Item", "");

XmlAttribute att = xmlnode.OwnerDocument.CreateAttribute("type");

att.Value = GActorHelper.getActorTypestr(subactor);

node.Attributes.Append(att);

subactor.serialize(node, edititem, load, clipboard);

xmlnode.InsertAfter(node, xmlnode.LastChild);

}

return true;

}

// 保存物品

virtual public bool serialize(BinaryWriter binWriter)

{

binWriter.Write(hide);

binWriter.Write(freeze);

for (int i = 0; i < 16; i++)

{

binWriter.Write(locationmat[i]);

}

return true;

}

// 读取物品

virtual public bool serialize(BinaryReader binReader, IEditItem edititem)

{

notifyPropertyChange("Hide", binReader.ReadBoolean().ToString());

notifyPropertyChange("Freeze", binReader.ReadBoolean().ToString());

float[] locarray = new float[16];

for (int i = 0; i < 16; i++)

{

locarray[i] = binReader.ReadSingle();

}

// 恢复保存到二进制文件的Prefeb实例的位置

if (this is PrefebActor)

{

Vector3F pos = new Vector3F(locarray[3], locarray[7], locarray[11]);

Vector3F posold = GActorHelper.getMinPos(getActorBuffer().getOrgBuffer());

foreach (IActor subactor in getActorBuffer().getOrgBuffer())

{

subactor.move(pos - posold);

}

notifyPropertyChange("LocationMat", (new Matrix4F(locarray)).ToString());

return true;

}

virtual public void pushHardwareSelect(ClientBridge.ClientRenderSys rendersys)

{

return;

}

public virtual void pushLineHardwareSelect(ClientBridge.ClientRenderSys rendersys)

{

return;

}

// 获取物体是否可见

public virtual bool isVisible()

{

return !(hide || BaseCommand.isActorLayerReadOnly(parentLayer, BaseCommand.ACTORLAYER_ITERATE_MODE.HIDE));

}

public virtual bool mouseHover(Rect<int> rect, IView view)

{

return true;

}

public virtual bool mouseSelect(Rect<int> rect, IView view)

{

return true;

}

// 得到物品类别字符串

virtual public string getActorTypestr()

{

return "Actor";

}

//父物品层Hide操作回调

virtual public void notifyLayerHide(bool isHide)

{

if (!hide && getActorBuffer() != null)

getActorBuffer().notifyLayerHide(isHide);

}

//父物品层Freeze操作回调

virtual public void notifyLayerFreeze(bool isFreeze)

{

if (!freeze && getActorBuffer() != null)

getActorBuffer().notifyLayerFreeze(isFreeze);

}

public virtual System.Xml.Schema.XmlSchema GetSchema()

{

throw new NotImplementedException();

}

public virtual void ReadXmlInner(System.Xml.XmlReader reader)

{

this.giid = (GIID)Serializer.ReadXmlObj(reader, "giid");

this.hide = (bool)Serializer.ReadXmlObj(reader, "hide");

this.freeze = (bool)Serializer.ReadXmlObj(reader, "freeze");

SDictionary<string, string> temp

= (SDictionary<String, String>)Serializer.ReadXmlObj(reader, "m_property_dic");

this.m_property_dic = SDictionary<string, string>.ToDic(temp);

this.locationmat = (Matrix4F)Serializer.ReadXmlObj(reader, "locationmat");

this.aabb = (AxisAlignedBox)Serializer.ReadXmlObj(reader, "aabb");

this.center = (Vector3F)Serializer.ReadXmlObj(reader, "center");

this.genlightmap = (bool)Serializer.ReadXmlObj(reader, "genlightmap");

this.castshadow = (bool)Serializer.ReadXmlObj(reader, "castshadow");

this.m_scale = (Vector3F)Serializer.ReadXmlObj(reader, "m_scale");

this.m_trans = (Vector3F)Serializer.ReadXmlObj(reader, "m_trans");

this.m_euler = (Vector3F)Serializer.ReadXmlObj(reader, "m_euler");

}

public virtual void ReadXml(XmlReader reader)

{

Serializer.PreReadXmlObj(reader);

ReadXmlInner(reader);

Serializer.AfterReadXmlObj(reader);

}

public virtual void WriteXml(XmlWriter writer)

{

Serializer.WriteXmlObj(writer, this.giid, "giid");

Serializer.WriteXmlObj(writer, this.hide, "hide");

Serializer.WriteXmlObj(writer, this.freeze, "freeze");

SDictionary<string, string> temp = SDictionary<string, string>.ToSDic(m_property_dic);

Serializer.WriteXmlObj(writer, temp, "m_property_dic");

Serializer.WriteXmlObj(writer, this.locationmat, "locationmat");

Serializer.WriteXmlObj(writer, this.aabb, "aabb");

Serializer.WriteXmlObj(writer, this.center, "center");

Serializer.WriteXmlObj(writer, this.genlightmap, "genlightmap");

Serializer.WriteXmlObj(writer, this.castshadow, "castshadow");

Serializer.WriteXmlObj(writer, this.m_scale, "m_scale");

Serializer.WriteXmlObj(writer, this.m_trans, "m_trans");

Serializer.WriteXmlObj(writer, this.m_euler, "m_euler");

}

public enum DETAIL_ACTOR_TYPE

{

DAT_HUGE_ACTOR,

DAT_SMALL_ACTOR,

DAT_DETAIL_VEGETATION,

}

// 模型信息

public class ModelActorInfo

{

public string m_model_name; // 物品名称前缀+id

public string m_resouce_name; // 资源名成

public float m_height; // 距离地面高度

public bool m_collide;

public bool m_is_bridge;

public bool m_visible_ingame;

public float m_visible_distance; // 可见范围

public bool m_far_object; // 远处的对象

public bool m_is_tree;

public bool m_temp_transparent;

public bool m_reflection;

public bool m_lightable = false; //是否接受光斑

public bool m_use_lightmap = true; //是否应用Lightmap

//public bool m_selshadow_in_lightmap = false; //Ligthmap中是否有自阴影

public string m_lightmap_quality = "普通"; //Lightmap质量

public DETAIL_ACTOR_TYPE m_dat = DETAIL_ACTOR_TYPE.DAT_SMALL_ACTOR; // 细节物体类型

public bool m_as_actor; // 是否受角色光

public ModelActorInfo(Dictionary<string, string> createpropdic, int curindex)

{

string nameprefix = "M_" + createpropdic["NamePrefix"];

m_model_name = nameprefix + "_" + curindex.ToString();

m_resouce_name = createpropdic["ResName"];

try

{

m_height = float.Parse(createpropdic["Height"]);

}

catch (Exception)

{

m_height = 0;

}

m_collide = false;

m_is_bridge = false;

m_visible_ingame = true;

m_far_object = false;

m_is_tree = false;

m_temp_transparent = true;

m_lightable = false;

m_use_lightmap = true;

//m_selshadow_in_lightmap = false;

m_lightmap_quality = "普通";

m_as_actor = false;

if (createpropdic.ContainsKey("碰撞物体"))

{

m_collide = createpropdic["碰撞物体"].ToLower() == "true";

}

if (createpropdic.ContainsKey("桥梁物体"))

{

m_is_bridge = createpropdic["桥梁物体"].ToLower() == "true";

}

if (createpropdic.ContainsKey("游戏中可见"))

{

m_visible_ingame = createpropdic["游戏中可见"].ToLower() == "true";

}

if (createpropdic.ContainsKey("可视距离"))

{

if (!float.TryParse(createpropdic["可视距离"], out m_visible_distance))

{

m_visible_distance = 1000;

}

else

{

m_visible_distance = 1000;

}

if (createpropdic.ContainsKey("远景"))

{

m_far_object = createpropdic["远景"].ToLower() == "true";

}

if (createpropdic.ContainsKey("是否是树"))

{

m_is_tree = createpropdic["是否是树"].ToLower() == "true";

}

if (createpropdic.ContainsKey("临时透明"))

{

m_temp_transparent = createpropdic["临时透明"].ToLower() == "true";

}

m_reflection = true;

if (createpropdic.ContainsKey("反射中绘制"))

{

bool.TryParse(createpropdic["反射中绘制"], out m_reflection);

}

if (createpropdic.ContainsKey("是否接受光斑"))

{

m_lightable = createpropdic["是否接受光斑"].ToLower() == "true";

}

if (createpropdic.ContainsKey("是否应用Lightmap"))

{

m_use_lightmap = createpropdic["是否应用Lightmap"].ToLower() == "true";

}

//if (createpropdic.ContainsKey("Ligthmap中是否有自阴影"))

//{

// m_selshadow_in_lightmap = createpropdic["Ligthmap中是否有自阴影"].ToLower() == "true";

//}

if (createpropdic.ContainsKey("Lightmap质量"))

{

m_lightmap_quality = createpropdic["Lightmap质量"];

}

if (createpropdic.ContainsKey("细节物体类型"))

{

m_dat = (DETAIL_ACTOR_TYPE)Enum.Parse(typeof(DETAIL_ACTOR_TYPE), createpropdic["细节物体类型"], true);

}

if (createpropdic.ContainsKey("受角色光"))

{

bool.TryParse(createpropdic["受角色光"], out m_as_actor);

}

public ModelActorInfo(string modelname, string resname, float height)

{

m_model_name = modelname;

m_resouce_name = resname;

m_height = height;

}

public ModelActorInfo(string modelname, string resname, float height, bool collide, bool is_bridge, bool visible_ingame, float visible_distance, bool far_object, bool is_tree, bool temp_transparent, bool reflection)

{

m_model_name = modelname;

m_resouce_name = resname;

m_height = height;

m_collide = collide;

m_is_bridge = is_bridge;

m_visible_ingame = visible_ingame;

m_visible_distance = visible_distance;

m_far_object = far_object;

m_is_tree = is_tree;

m_temp_transparent = temp_transparent;

m_reflection = reflection;

m_lightable = false;

m_use_lightmap = true;

//m_selshadow_in_lightmap = false;

m_lightmap_quality = "普通";

m_dat = DETAIL_ACTOR_TYPE.DAT_SMALL_ACTOR;

m_as_actor = false;

}

// 转换成属性列表

public void toDic(Dictionary<string, string> dic)

{

dic["Name"] = m_model_name;

dic["ResName"] = m_resouce_name;

dic["Height"] = m_height.ToString();

dic["碰撞物体"] = m_collide.ToString();

dic["桥梁物体"] = m_is_bridge.ToString();

dic["游戏中可见"] = m_visible_ingame.ToString();

//dic["可视距离"] = m_visible_distance.ToString();

dic["远景"] = m_far_object.ToString();

dic["是否是树"] = m_is_tree.ToString();

dic["临时透明"] = m_temp_transparent.ToString();

dic["反射中绘制"] = m_reflection.ToString();

dic["是否接受光斑"] = m_lightable.ToString();

dic["是否应用Lightmap"] = m_use_lightmap.ToString();

//dic["Ligthmap中是否有自阴影"] = m_selshadow_in_lightmap.ToString();

dic["Lightmap质量"] = m_lightmap_quality;

dic["受角色光"] = m_as_actor.ToString();

string dat;

if (m_dat == DETAIL_ACTOR_TYPE.DAT_DETAIL_VEGETATION)

dat = "细节植被";

else if (m_dat == DETAIL_ACTOR_TYPE.DAT_HUGE_ACTOR)

dat = "大型物体";

else

dat = "小型物体";

dic["细节物体类型"] = dat;

}

public ModelActorInfo()

{

}

// 转换成存储列表

public void toDicAll(Dictionary<string, string> dic)

{

dic["Name"] = m_model_name;

dic["ResName"] = m_resouce_name;

dic["Height"] = m_height.ToString();

dic["碰撞物体"] = m_collide.ToString();

dic["桥梁物体"] = m_is_bridge.ToString();

dic["游戏中可见"] = m_visible_ingame.ToString();

dic["可视距离"] = m_visible_distance.ToString();

dic["远景"] = m_far_object.ToString();

dic["是否是树"] = m_is_tree.ToString();

dic["临时透明"] = m_temp_transparent.ToString();

dic["反射中绘制"] = m_reflection.ToString();

dic["是否接受光斑"] = m_lightable.ToString();

dic["是否应用Lightmap"] = m_use_lightmap.ToString();

//dic["Ligthmap中是否有自阴影"] = m_selshadow_in_lightmap.ToString();

dic["Lightmap质量"] = m_lightmap_quality;

dic["细节物体类型"] = m_dat.ToString();

dic["受角色光"] = m_as_actor.ToString();

}

public int getLightmapQualityPower(string value)

{

switch (value)

{

case "最低":

return -2;

case "低":

return -1;

case "普通":

return 0;

case "高":

return 1;

case "最高":

return 2;

default:

return int.MaxValue;

}

// 更新属性值

public void valueChanged(string key, string value)

{

switch (key)

{

case "Name":

m_model_name = value;

break;

case "ResName":

m_resouce_name = value;

break;

case "Height":

try

{

m_height = float.Parse(value);

}

catch (Exception)

{

m_height = 0;

}

break;

case "碰撞物体":

m_collide = value.ToLower() == "true";

break;

case "桥梁物体":

m_is_bridge = value.ToLower() == "true";

break;

case "游戏中可见":

m_visible_ingame = value.ToLower() == "true";

break;

case "可视距离":

float.TryParse(value, out m_visible_distance);

break;

case "远景":

m_far_object = value.ToLower() == "true";

break;

case "是否是树":

m_is_tree = value.ToLower() == "true";

break;

case "临时透明":

m_temp_transparent = value.ToLower() == "true";

break;

case "反射中绘制":

bool.TryParse(value, out m_reflection);

break;

case "是否接受光斑":

m_lightable = value.ToLower() == "true";

break;

case "是否应用Lightmap":

m_use_lightmap = value.ToLower() == "true";

break;

//case "Ligthmap中是否有自阴影":

// m_selshadow_in_lightmap = value.ToLower() == "true";

// break;

case "Lightmap质量":

m_lightmap_quality = value;

break;

case "细节物体类型":

if (value == "大型物体" || value == DETAIL_ACTOR_TYPE.DAT_HUGE_ACTOR.ToString())

m_dat = DETAIL_ACTOR_TYPE.DAT_HUGE_ACTOR;

if (value == "小型物体" || value == DETAIL_ACTOR_TYPE.DAT_SMALL_ACTOR.ToString())

m_dat = DETAIL_ACTOR_TYPE.DAT_SMALL_ACTOR;

if (value == "细节植被" || value == DETAIL_ACTOR_TYPE.DAT_DETAIL_VEGETATION.ToString())

m_dat = DETAIL_ACTOR_TYPE.DAT_DETAIL_VEGETATION;

break;

case "受角色光":

bool.TryParse(value, out m_as_actor);

break;

default:

break;

}

// 模型

public class ModelActor : ResActorBase, IActor

{

public ModelActor(GIIDMng giidmng, Dictionary<string, string> createpropdic, ClientBridge.ClientRenderSys rendersys, int curindex)

: base(giidmng)

{

m_actor_info = new ModelActorInfo(createpropdic, curindex);

m_model = rendersys.createModel(m_actor_info.m_resouce_name);

if (m_model == null)

{

return;

}

//m_model.setVisibleDist(visible_distance);

notifyPropertyChange("实时阴影", "True");

//notifyPropertyChange("是否是树", "False");

//notifyPropertyChange("临时透明", "True");

return;

}

public ModelActor(GIIDMng giidmng)

: base(giidmng)

{

m_actor_info = new ModelActorInfo();

if (m_model != null)

notifyPropertyChange("实时阴影", "True");

//notifyPropertyChange("是否是树", "False");

//notifyPropertyChange("临时透明", "True");

//notifyPropertyChange("反射中绘制", "True");

return;

}

override public void Attach(ClientBridge.SceneBase scene)

{

if (m_model != null)

{

m_model.Attach(scene);

}

override public void Detach(ClientBridge.SceneBase scene)

{

if (m_model != null)

{

m_model.Detach(scene);

}

override public void SetLod(ClientBridge.LOD_LEVEL lod)

{

if (m_model != null)

{

//m_model.setMaterialLod(lod);

}

override public bool hide

{

get { return base.hide; }

set

{

base.hide = value;

//父层为Hide，只设置标识位，否则进行具体Hide操作

if (m_model != null && !BaseCommand.isActorLayerReadOnly(parentLayer, BaseCommand.ACTORLAYER_ITERATE_MODE.HIDE))

{

//m_model.setVisible(!value);

}

public override void notifyLayerFreeze(bool isFreeze)

{

//base.notifyLayerFreeze(isFreeze);

}

//父物品层设置Hide通知

public override void notifyLayerHide(bool isHide)

{

if (hide)

return;

//if(m_model != null)

// m_model.setVisible(!isHide);

}

public override string name

{

get

{

return m_actor_info.m_model_name;

}

set

{

m_actor_info.m_model_name = value;

}

public string res

{

get

{

return m_actor_info.m_resouce_name;

}

public bool collide

{

get

{

return m_actor_info.m_collide;

}

public bool is_bridge

{

get

{

return m_actor_info.m_is_bridge;

}

public bool visible_ingame

{

get

{

return m_actor_info.m_visible_ingame;

}

public float visible_distance

{

get

{

return m_actor_info.m_visible_distance;

}

public bool far_object

{

get

{

return m_actor_info.m_far_object;

}

public bool is_tree

{

get

{

return m_actor_info.m_is_tree;

}

public bool temp_transparent

{

get

{

return m_actor_info.m_temp_transparent;

}

#region about IDisposable

virtual public void Dispose()

{

m_model.release();

}

#endregion

#region about IActor

// fixme : 各类物品的Clone目前都还没有实现

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

ModelActor actor = null;

return actor;

}

new public IMemento getMemento(int mode)

{

return null;

}

new public void setMemento(IMemento mem)

{

}

public override bool serialize(BinaryWriter binWriter)

{

binWriter.Write(m_actor_info.m_model_name);

binWriter.Write(m_actor_info.m_resouce_name);

binWriter.Write(m_actor_info.m_height);

return base.serialize(binWriter);

}

public override bool serialize(BinaryReader binReader, IEditItem edititem)

{

m_actor_info.m_model_name = binReader.ReadString();

m_actor_info.m_resouce_name = binReader.ReadString();

m_actor_info.m_height = binReader.ReadSingle();

RootEditItem root = (RootEditItem)(SceneGraph.getEditItemCommon("RootItem", edititem));

m_model = root.clientRenderSys.createModel(m_actor_info.m_resouce_name);

return base.serialize(binReader, edititem);

}

public override bool serialize(System.Xml.XmlNode xmlnode, IEditItem edititem, bool load, bool clipboard)

{

base.serialize(xmlnode, edititem, load, clipboard);

if (load)

{

RootEditItem root = (RootEditItem)(SceneGraph.getEditItemCommon("RootItem", edititem));

m_model = root.clientRenderSys.createModel(m_actor_info.m_resouce_name);

}

updateLocationAABB();

return true;

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

// 调用自己的绘制函数

m_model.render();

}

public override void renderAABB(int t, ClientBridge.ClientRenderSys rendersys, Color color)

{

base.renderAABB(t, rendersys, color);

}

#endregion

public override IDictionary<string, string> getPropertyList()

{

m_actor_info.toDic(m_property_dic);

return base.getPropertyList();

}

public override void updateLocationAABB()

{

if (m_model == null)

{

return;

}

// 设置mat

List<float> matrix = new List<float>();

for (int i = 0; i < 16; i++)

{

matrix.Add(locationmat[i]);

}

m_model.setLocationMatrix(matrix);

// 修改包围盒

List<float> aabblist = new List<float>();

for (int i = 0; i < 6; i++)

{

aabblist.Add(0);

}

m_model.getAABB(aabblist);

aabb = new AxisAlignedBox(new Vector3F(aabblist[0], aabblist[1], aabblist[2]),

new Vector3F(aabblist[3], aabblist[4], aabblist[5]));

base.updateLocationAABB();

}

public override void pushHardwareSelect(ClientBridge.ClientRenderSys rendersys)

{

rendersys.pushHardwareSelectObject(m_model, (uint)giid.value);

}

public override void notifyPropertyChange(String key, String value)

{

if (key == "Lightmap质量")

{

int cur_p = m_actor_info.getLightmapQualityPower(m_actor_info.m_lightmap_quality);

int new_p = m_actor_info.getLightmapQualityPower(value);

if (new_p == int.MaxValue)

{

return;

}

//if (!m_model.setLightmapQuality(new_p))

//{

// if (new_p > cur_p)

// {

// MessageBox.Show("不允许再提升质量");

// }

// else if (new_p < cur_p)

// {

// MessageBox.Show("不允许再降低质量");

// }

// return;

//}

}

if (key != "可视距离")

base.notifyPropertyChange(key, value);

m_actor_info.valueChanged(key, value);

if (m_model != null)

{

if (key == "可视距离")

{

//m_model.setVisibleDist(visible_distance);

}

else if (key == "实时阴影")

{

//m_model.setCastShadow(base.castshadow);

}

else if (key == "反射中绘制")

{

//m_model.setReflection(m_actor_info.m_reflection);

}

else if (key == "是否接受光斑")

{

//m_model.setLightable(m_actor_info.m_lightable);

}

else if (key == "受角色光")

{

//m_model.asActor(m_actor_info.m_as_actor);

}

public override string getActorTypestr()

{

return "模型";

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_DML;

}

public ModelActorInfo m_actor_info;

public ClientBridge.Model m_model;

override public string ResName

{

get { return res; }

}

override public object getRes()

{

return m_model;

}

public override void changeRes(ClientBridge.ClientRenderSys rendersys, string new_res)

{

if (m_model != null)

{

m_model.changeRes(rendersys, new_res);

m_actor_info.m_resouce_name = new_res;

updateLocationAABB();

}

override public void addRef()

{

if (m_model != null)

{

m_model.addRef();

}

override public int ResRefCount

{

get

{

if (m_model != null)

{

return m_model.m_ref_count;

}

else

{

return 0;

}

// 骨骼模型

public class SkeletonModelActor : ActorBase, IActor

{

public SkeletonModelActor(GIIDMng giidmng, Dictionary<string, string> createpropdic, ClientBridge.ClientRenderSys rendersys, int curindex)

: base(giidmng)

{

m_actor_info = new ModelActorInfo(createpropdic, curindex);

m_model = rendersys.creatSkeletonModel(m_actor_info.m_resouce_name);

//m_model.setVisibleDist(visible_distance);

return;

}

public SkeletonModelActor(GIIDMng giidmng)

: base(giidmng)

{

m_actor_info = new ModelActorInfo();

return;

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_CHR;

}

override public bool hide

{

get { return base.hide; }

set

{

base.hide = value;

}

public override string name

{

get

{

return m_actor_info.m_model_name;

}

public string res

{

get

{

return m_actor_info.m_resouce_name;

}

virtual public void Dispose()

{

if (m_model != null)

{

m_model.release();

}

#region about IActor

// fixme : 各类物品的Clone目前都还没有实现

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

ModelActor actor = null;

return actor;

}

protected void getSaveProperty(Dictionary<string, string> mPro)

{

foreach (KeyValuePair<string, string> kv in base.getPropertyList())

{

mPro[kv.Key] = kv.Value;

}

public override void update(int t)

{

if (hide == false)

{

m_model.update(((float)t) / 1.0f);

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

if (!hide)

{

m_model.render();

}

public override void renderAABB(int t, ClientBridge.ClientRenderSys rendersys, Color color)

{

base.renderAABB(t, rendersys, color);

}

#endregion

public override IDictionary<string, string> getPropertyList()

{

m_actor_info.toDic(m_property_dic);

return base.getPropertyList();

}

public void updateAABB()

{

// 修改包围盒

List<float> aabblist = new List<float>();

for (int i = 0; i < 6; i++)

{

aabblist.Add(0);

}

m_model.getAABB(aabblist);

aabb = new AxisAlignedBox(new Vector3F(aabblist[0], aabblist[1], aabblist[2]),

new Vector3F(aabblist[3], aabblist[4], aabblist[5]));

}

public override void updateLocationAABB()

{

if (m_model == null)

{

return;

}

// 设置mat

List<float> matrix = new List<float>();

for (int i = 0; i < 16; i++)

{

matrix.Add(locationmat[i]);

}

m_model.setLocationMatrix(matrix);

updateAABB();

}

public override void pushHardwareSelect(ClientBridge.ClientRenderSys rendersys)

{

rendersys.pushHardwareSelectObject(m_model, (uint)giid.value);

}

public override void notifyPropertyChange(String key, String value)

{

base.notifyPropertyChange(key, value);

m_actor_info.valueChanged(key, value);

}

public ModelActorInfo m_actor_info;

public ClientBridge.SkeletonModel m_model;

public void SetAction(int trackid, string actionname)

{

m_model.setAim(trackid, actionname);

}

public void SetActionTime(int trackid, float time)

{

m_model.SetCurrentActionTime(trackid, time);

}

public void PlayAction(int trackid, float time)

{

m_model.SetCurrentActionTime(trackid, time);

// m_model.update(0);

// m_irender.updatePhx((int)(0));//time*1000f

}

public void ClearChannelAnim(int id)

{

m_model.ClearChannelAnim(0);

}

public Vector3F GetPosFromRootBone()

{

if (m_model!=null)

{

string rootName = m_model.GetRootBoneName();

int rootID = m_model.GetBoneID(rootName);

List<float> mat = m_model.GetBoneLocation(rootID);

return new Vector3F(mat[3],mat[7],mat[11]);

}

return new Vector3F(0.0f,0.0f,0.0f);

}

// 角色

public class StageRoleActor : SkeletonModelActor

{

public StageRoleActor(GIIDMng giidmng, Dictionary<string, string> createpropdic, ClientBridge.ClientRenderSys rendersys, int curindex, bool male)

: base(giidmng)

{

m_crs = rendersys;

m_actor_info = new ModelActorInfo(createpropdic, curindex);

m_actor_model = m_crs.creatActorModel("StageRoleActor" + curindex.ToString(), male);

base.m_model = (ClientBridge.SkeletonModel)m_actor_model;

notifyPropertyChange("产生阴影", "True");

notifyPropertyChange("Update", "True");

return;

}

public override void update(int t)

{

base.update(t);

updateAABB();

}

public void SetBodyPart(int pos, string bpt_filename)

{

m_actor_model.SetBodyPart(pos, bpt_filename);

}

public void SetAdornment(ClientBridge.SpecialEffectMng sem, int pos, string lik_filename)

{

m_actor_model.SetAdornment(sem, pos, lik_filename);

}

public void PostProcessCreating()

{

m_actor_model.PostProcessCreating();

}

public override int flag

{

get { return (int)ActorFlag.UNDELETEABLE | (int)ActorFlag.UNSERIALIZABLE; }

}

public override void notifyPropertyChange(string key, string value)

{

if (key != "ResName")

{

base.notifyPropertyChange(key, value);

}

private ClientBridge.ClientRenderSys m_crs;

private ClientBridge.ActorModel m_actor_model;

}

// 特效信息

public struct EffectActorInfo

{

public string m_effect_name; // 物品名称前缀+id

public string m_resouce_name;

public float m_visible_distance;

public float m_height;

public bool m_reflection;

public bool m_as_actor;

public float m_random_offset_min;

public float m_random_offset_max;

public EffectActorInfo(Dictionary<string, string> createpropdic, int curindx)

{

string nameprefix = "E_" + createpropdic["NamePrefix"];

m_effect_name = nameprefix + "_" + curindx.ToString();

m_resouce_name = createpropdic["ResName"];

if (createpropdic.ContainsKey("可视距离"))

{

if (!float.TryParse(createpropdic["可视距离"], out m_visible_distance))

{

m_visible_distance = 1000;

}

else

{

m_visible_distance = 1000;

}

try

{

m_height = float.Parse(createpropdic["Height"]);

}

catch (Exception)

{

m_height = 0;

}

m_reflection = true;

if (createpropdic.ContainsKey("反射中绘制"))

{

bool.TryParse(createpropdic["反射中绘制"], out m_reflection);

}

m_as_actor = false;

if (createpropdic.ContainsKey("受角色光"))

{

bool.TryParse(createpropdic["受角色光"], out m_as_actor);

}

try

{

m_random_offset_min = float.Parse(createpropdic["随机动画偏移最小值"]);

m_random_offset_max = float.Parse(createpropdic["随机动画偏移最大值"]);

}

catch (Exception)

{

m_random_offset_min = 0;

m_random_offset_max = 0;

}

public EffectActorInfo(string effectname, string resname, float height)

{

m_effect_name = effectname;

m_resouce_name = resname;

m_height = height;

m_visible_distance = 0;

m_reflection = true;

m_as_actor = false;

m_random_offset_min = 0;

m_random_offset_max = 0;

}

public EffectActorInfo(string effectname, string resname, float height, float visible_distance, bool reflection)

{

m_effect_name = effectname;

m_resouce_name = resname;

m_height = height;

m_visible_distance = visible_distance;

m_reflection = reflection;

m_as_actor = false;

m_random_offset_min = 0;

m_random_offset_max = 0;

}

public void toDic(Dictionary<string, string> dic)

{

dic["Name"] = m_effect_name;

dic["ResName"] = m_resouce_name;

dic["Height"] = m_height.ToString();

dic["反射中绘制"] = m_reflection.ToString();

dic["受角色光"] = m_as_actor.ToString();

dic["随机动画偏移最小值"] = m_random_offset_min.ToString();

dic["随机动画偏移最大值"] = m_random_offset_max.ToString();

}

public void toDicAll(Dictionary<string, string> dic)

{

dic["Name"] = m_effect_name;

dic["ResName"] = m_resouce_name;

dic["Height"] = m_height.ToString();

dic["可视距离"] = m_visible_distance.ToString();

dic["反射中绘制"] = m_reflection.ToString();

dic["受角色光"] = m_as_actor.ToString();

dic["随机动画偏移最小值"] = m_random_offset_min.ToString();

dic["随机动画偏移最大值"] = m_random_offset_max.ToString();

}

// 更新属性值

public void valueChanged(string key, string value)

{

switch (key)

{

case "Name":

m_effect_name = value;

break;

case "ResName":

m_resouce_name = value;

break;

case "Height":

float.TryParse(value, out m_height);

break;

case "可视距离":

float.TryParse(value, out m_visible_distance);

break;

case "反射中绘制":

bool.TryParse(value, out m_reflection);

break;

case "受角色光":

bool.TryParse(value, out m_as_actor);

break;

case "随机动画偏移最小值":

float.TryParse(value, out m_random_offset_min);

break;

case "随机动画偏移最大值":

float.TryParse(value, out m_random_offset_max);

break;

default:

break;

}

// 特效

public class EffectActor : ResActorBase, IActor

{

public EffectActor(GIIDMng giidmng, Dictionary<string, string> createpropdic, ClientBridge.ClientRenderSys rendersys, int curindex)

: base(giidmng)

{

m_actor_info = new EffectActorInfo(createpropdic, curindex);

m_effect = rendersys.getSpecialEffectMng().loadEffect(m_actor_info.m_resouce_name);

m_effect.play();

}

public EffectActor(GIIDMng giidmng)

: base(giidmng)

{

m_actor_info = new EffectActorInfo();

}

override public void Attach(ClientBridge.SceneBase scene)

{

if (m_effect != null)

{

m_effect.Attach(scene);

}

override public void Detach(ClientBridge.SceneBase scene)

{

if (m_effect != null)

{

m_effect.Detach(scene);

}

override public void SetLod(ClientBridge.LOD_LEVEL lod)

{

if (m_effect != null)

{

//m_effect.setMaterialLod(lod);

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_SPE;

}

override public bool hide

{

get { return base.hide; }

set

{

base.hide = value;

//若父层为Hide，则只改变标识位，不进行具体操作

if (m_effect != null && !BaseCommand.isActorLayerReadOnly(parentLayer, BaseCommand.ACTORLAYER_ITERATE_MODE.HIDE))

{

m_effect.setVisible(!value);

}

public override string name

{

get

{

return m_actor_info.m_effect_name;

}

public string res

{

get

{

return m_actor_info.m_resouce_name;

}

public float visible_distance

{

get

{

return m_actor_info.m_visible_distance;

}

public override AxisAlignedBox aabb

{

get { return base.aabb; }

set

{

m_aabb = value;

if (parentLayer != null && this is IActor)

{

parentLayer.OnActorAABBChanged((IActor)this, m_render_aabb);

}

// 更新物品中心

m_center = new Vector3F((m_aabb.Min.X + m_aabb.Max.X) / 2.0f, (m_aabb.Min.Y + m_aabb.Max.Y) / 2.0f, (m_aabb.Min.Z + m_aabb.Max.Z) / 2.0f);

}

#region about IDisposable

public void Dispose()

{

//m_effect.release(); // 有问题？

}

#endregion

#region about IActor

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

EffectActor actor = null;

return actor;

}

public override IDictionary<string, string> getPropertyList()

{

m_actor_info.toDic(m_property_dic);

return base.getPropertyList();

}

public override void updateLocationAABB()

{

if (m_effect == null)

{

return;

}

List<float> matrix = new List<float>();

for (int i = 0; i < 16; i++)

{

matrix.Add(locationmat[i]);

}

m_effect.setLocationMatrix(matrix);

//m_model.setLocationMatrix(matrix);

// 修改包围盒

List<float> aabblist = new List<float>();

for (int i = 0; i < 6; i++)

{

aabblist.Add(0);

}

m_effect.getAABB(aabblist);

m_render_aabb = new AxisAlignedBox(new Vector3F(aabblist[0], aabblist[1], aabblist[2]),

new Vector3F(aabblist[3], aabblist[4], aabblist[5]));

Vector3F trans = new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34);

aabb = new AxisAlignedBox(s_min + trans, s_max + trans);

base.updateLocationAABB();

m_pos = new Vector3F(locationmat.M14, locationmat.M24, locationmat.M34);

Vector4F nor = new Vector4F(0, 0, -1, 0);

nor = locationmat * nor;

m_nor = new Vector3F(nor.X, nor.Y, nor.Z);

}

// public override void pushHardwareSelect(ClientBridge.ClientRenderSys rendersys)

// {

// }

public override void pushLineHardwareSelect(ClientBridge.ClientRenderSys rendersys)

{

rendersys.pushSelectID((uint)giid.value);

rendersel(0, rendersys);

}

public override void notifyPropertyChange(String key, String value)

{

float min = m_actor_info.m_random_offset_min;

float max = m_actor_info.m_random_offset_max;

bool offsetChanged = false;

base.notifyPropertyChange(key, value);

m_actor_info.valueChanged(key, value);

if (m_effect != null)

{

if (key == "实时阴影")

{

//m_effect.setCastShadow(base.castshadow);

}

else if (key == "反射中绘制")

{

//m_effect.setReflection(m_actor_info.m_reflection);

}

else if (key == "受角色光")

{

//m_effect.asActor(m_actor_info.m_as_actor);

}

else if (key == "随机动画偏移最小值")

{

if (m_actor_info.m_random_offset_min < 0)

m_actor_info.m_random_offset_min = 0;

if (m_actor_info.m_random_offset_min > m_actor_info.m_random_offset_max)

{

m_actor_info.m_random_offset_max = m_actor_info.m_random_offset_min;

base.notifyPropertyChange("随机动画偏移最大值", m_actor_info.m_random_offset_max.ToString());

}

offsetChanged = min != m_actor_info.m_random_offset_min;

}

else if (key == "随机动画偏移最大值")

{

if (m_actor_info.m_random_offset_max < 0)

m_actor_info.m_random_offset_max = 0;

if (m_actor_info.m_random_offset_max < m_actor_info.m_random_offset_min)

{

m_actor_info.m_random_offset_min = m_actor_info.m_random_offset_max;

base.notifyPropertyChange("随机动画偏移最小值", m_actor_info.m_random_offset_min.ToString());

}

offsetChanged = max != m_actor_info.m_random_offset_max;

}

if (offsetChanged)

setRandomOffsetPlay();

}

//设置随机动画偏移

private void setRandomOffsetPlay()

{

Random ran = new Random(unchecked((int)DateTime.Now.Ticks));

float seed = (float)ran.NextDouble();

float result = (m_actor_info.m_random_offset_max - m_actor_info.m_random_offset_min) * seed + m_actor_info.m_random_offset_min;

m_effect.update(result, false);

}

//通知父层设置了Hide状态

public override void notifyLayerHide(bool isHide)

{

if (hide)

return;

if (m_effect != null)

m_effect.setVisible(!isHide);

}

//通知父层设置了Freeze状态

public override void notifyLayerFreeze(bool isFreeze)

{

//base.notifyLayerFreeze(isFreeze);

}

public override string getActorTypestr()

{

return "特效";

}

//public IMemento getMemento(int mode)

//{

// return null;

//}

//public void setMemento(IMemento mem)

//{

//}

public override void update(int t)

{

if (m_effect == null)

{

return;

}

m_effect.update(t);

updateLocationAABB();

}

public override bool serialize(BinaryWriter binWriter)

{

binWriter.Write(m_actor_info.m_effect_name);

binWriter.Write(m_actor_info.m_resouce_name);

binWriter.Write(m_actor_info.m_height);

return base.serialize(binWriter);

}

public override bool serialize(BinaryReader binReader, IEditItem edititem)

{

m_actor_info.m_effect_name = binReader.ReadString();

m_actor_info.m_resouce_name = binReader.ReadString();

m_actor_info.m_height = binReader.ReadSingle();

RootEditItem root = (RootEditItem)(SceneGraph.getEditItemCommon("RootItem", edititem));

m_effect = root.clientRenderSys.getSpecialEffectMng().loadEffect(m_actor_info.m_resouce_name);

m_effect.play();

return base.serialize(binReader, edititem); ;

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

// 调用自己的绘制函数

if (m_effect == null)

return;

m_effect.render();

}

public void drawRenderLine(int t, ClientBridge.ClientRenderSys rendersys)

{

float[] cy = { 1, 1, 0, 1 };

RenderHelper.RenderConic(0, m_pos, m_nor, 45, 10, cy, rendersys);

}

public void rendersel(int t, ClientBridge.ClientRenderSys rendersys)

{

drawRenderLine(t, rendersys);

}

public override void renderAABB(int t, ClientBridge.ClientRenderSys rendersys, Color color)

{

base.renderAABB(t, rendersys, color);

}

#endregion

public ClientBridge.SpecialEffect m_effect;

EffectActorInfo m_actor_info;

AxisAlignedBox m_render_aabb;

static Vector3F s_min = new Vector3F(-25, -25, -25);

static Vector3F s_max = new Vector3F(25, 25, 25);

Vector3F m_pos = new Vector3F(0, 0, 0);

Vector3F m_nor = new Vector3F(0, 0, -1);

override public string ResName

{

get { return res; }

}

override public object getRes()

{

return m_effect;

}

override public void reload()

{

m_effect.reload();

}

public override void changeRes(ClientBridge.ClientRenderSys rendersys, string new_res)

{

if (m_effect != null)

{

m_effect.changeRes(rendersys, new_res);

m_actor_info.m_resouce_name = new_res;

updateLocationAABB();

}

override public void addRef()

{

if (m_effect != null)

{

m_effect.addRef();

}

override public int ResRefCount

{

get

{

if (m_effect != null)

{

return m_effect.m_ref_count;

}

else

{

return 0;

}

// 声音

public class SoundActor : ActorBase, IActor

{

public SoundActor(GIIDMng giidmng)

: base(giidmng)

{

}

public void Dispose()

{

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_SOUND;

}

#region about IActor

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

SoundActor actor = new SoundActor(root.giidmng);

actor.hide = hide;

actor.freeze = freeze;

return actor;

}

new public IMemento getMemento(int mode)

{

return null;

}

new public void setMemento(IMemento mem)

{

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

// 调用自己的绘制函数

}

#endregion

}

// AI节点

public class AINodeActor : ActorBase, IActor

{

public AINodeActor(GIIDMng giidmng)

: base(giidmng)

{

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_AINODE;

}

#region about IDisposable

public void Dispose()

{

}

#endregion

#region about IActor

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

AINodeActor actor = new AINodeActor(root.giidmng);

actor.hide = hide;

actor.freeze = freeze;

return actor;

}

new public IMemento getMemento(int mode)

{

return null;

}

new public void setMemento(IMemento mem)

{

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

// 调用自己的绘制函数

}

#endregion

}

public enum LightShape

{

CIRCLE = 0,

RECT = 1

}

// 灯光信息

public struct LightInfo

{

LightInfo(string type)

{

m_type = type;

m_spe_color = new Color();

m_dif_color = new Color();

m_amb_color = new Color();

}

LightInfo(string type, Color difcolor, Color speccolor, Color ambcolor)

{

m_type = type;

m_dif_color = difcolor;

m_spe_color = speccolor;

m_amb_color = ambcolor;

}

public string m_type;

public Color m_dif_color;

public Color m_spe_color;

public Color m_amb_color;

}

// 区域灯光

public class LightActor : ActorBase, IActor

{

public LightActor(GIIDMng giidmng, LightInfo lightinfo, ClientBridge.ClientRenderSys rendersys)

: base(giidmng)

{

m_light_info = lightinfo;

m_light = rendersys.createLight(lightinfo.m_type);

}

public LightActor(GIIDMng giidmng)

: base(giidmng)

{

m_light_info = new LightInfo();

}

public override ACTOR_TYPE GetActorType()

{

return ACTOR_TYPE.AT_LIGHT;

}

public void Dispose()

{

}

public IActor clone(IEditItem edititem)

{

RootEditItem root = (RootEditItem)SceneGraph.getEditItemCommon("RootItem", edititem);

LightActor actor = new LightActor(root.giidmng, m_light_info, root.clientRenderSys);

actor.hide = hide;

actor.freeze = freeze;

return actor;

}

new public IMemento getMemento(int mode)

{

return null;

}

new public void setMemento(IMemento mem)

{

}

public override void render(int t, ClientBridge.ClientRenderSys rendersys)

{

// 调用自己的绘制函数

}

override public void Attach(ClientBridge.SceneBase scene)

{

if (m_light != null)

{

//m_light.Attach(scene);

}

override public void Detach(ClientBridge.SceneBase scene)

{

if (m_light != null)

{

//m_light.Detach(scene);

}

ClientBridge.Light m_light;

LightInfo m_light_info;

}

//操作方式

public enum ActorActionState

{

SELECT,

MOVE,

ROTATE,

DRAG,

RESIZE,

}

// 移动方向

public enum MoveDirection

{

MD_NONE = 0, // 不移动

MD_X = 0x01 << 0, // 沿X轴移动

MD_Y = 0x01 << 1, // 沿Y轴移动

MD_Z = 0x01 << 2, // 沿Z轴移动

MD_XY = MD_X | MD_Y, // 在XY平面移动

MD_XZ = MD_X | MD_Z, // 在XZ平面移动

MD_YZ = MD_Y | MD_Z, // 在YZ平面移动

}

// 旋转轴

public enum RotateDirection

{

RD_NONE, // 不旋转

RD_X, // 沿X轴旋转

RD_Y, // 沿Y轴旋转

RD_Z // 沿Z轴旋转

}

// 旋转方式

public enum RotateMode

{

RM_WHOLE, // 绕同一个轴

RM_SELF, // 绕自身轴

RM_BOTH // fixme:

}

public enum ResizeDirection

{

RD_NONE = 0, // 不移动

RD_X = 0x01 << 0, // 沿X轴移动

RD_Y = 0x01 << 1, // 沿Y轴移动

RD_Z = 0x01 << 2, // 沿Z轴移动

RD_XY = RD_X | RD_Y, // 在XY平面移动

RD_XZ = RD_X | RD_Z, // 在XZ平面移动

RD_YZ = RD_Y | RD_Z,

RD_XYZ = RD_X | RD_Y | RD_Z

}

public class RenderHelper

{

public static float stdDist = 50.0f;

public static float GetFakeLength(Vector3F center, float reallength, float fstdDist, IView view)

{

Vector3F ca_pos = view.getCamera().getCameraPosition();

float dis = ComputeDisBetweenTwoPoint(center, ca_pos);

reallength *= dis / fstdDist;

return reallength;

}

public static void drawCircle(Vector3F center, Vector3F normal, float radius, float[] color, ClientBridge.ClientRenderSys rendersys)

{

normal.Normalize();

// 用360个点的连线模拟圆

int pointcount = 360;

float[] points = new float[pointcount * 3];

//int[] indexs = new int[pointcount*3 + 1];

int[] indexs = new int[pointcount + 1];

for (int t = 0; t < pointcount; t++)

{

float factor = 0;

Vector3F u = new Vector3F();

if (Math.Abs(normal.X) > Math.Abs(normal.Y))

{

factor = 1.0f / (float)Math.Sqrt(normal.X * normal.X + normal.Z * normal.Z);

u.X = -normal.Z * factor;

u.Y = 0;

u.Z = normal.X * factor;

}

else

{

factor = 1.0f / (float)Math.Sqrt(normal.Y * normal.Y + normal.Z * normal.Z);

u.X = 0;

u.Y = normal.Z * factor;

u.Z = -normal.Y * factor;

}

u.Normalize();

Vector3F v = Vector3F.CrossProduct(normal, u);

v.Normalize();

points[t * 3] = (float)(center.X + (radius * Math.Cos(Math.PI * t / 180.0f)) * u.X + (radius * Math.Sin(Math.PI * t / 180.0f)) * v.X);

points[t * 3 + 1] = (float)(center.Y + (radius * Math.Cos(Math.PI * t / 180.0f)) * u.Y + (radius * Math.Sin(Math.PI * t / 180.0f)) * v.Y);

points[t * 3 + 2] = (float)(center.Z + (radius * Math.Cos(Math.PI * t / 180.0f)) * u.Z + (radius * Math.Sin(Math.PI * t / 180.0f)) * v.Z);

indexs[t] = t;

}

indexs[pointcount] = 0;

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs, color, true);

}

public static void drawRotateCircles(Vector3F center, IView view, float[] circlexy, float[] circleyz, float[] circlexz, bool hardsel)

{

drawRotateCircles(center, view, circlexy, circleyz, circlexz, hardsel, Matrix3F.Identity);

}

public static void drawRotateCircles(Vector3F center, IView view, float[] circlexy, float[] circleyz, float[] circlexz, bool hardsel, Matrix3F rotmat)

{

drawRotateCircles(center, view, 10.0f, circlexy, circleyz, circlexz, hardsel, rotmat);

}

public static void DrawMoustSelectRect(int x1, int y1, int x2, int y2, IView view)

{

Vector3F p1 = view.getCamera().GetScreenXYZ(x1, y1, view.getRenderSys());

Vector3F p2 = view.getCamera().GetScreenXYZ(x2, y2, view.getRenderSys());

Vector3F p3 = view.getCamera().GetScreenXYZ(x1, y2, view.getRenderSys());

Vector3F p4 = view.getCamera().GetScreenXYZ(x2, y1, view.getRenderSys());

Vector3F p_p1 = new Vector3F(p1.X - view.getCamera().position.x, p1.Y - view.getCamera().position.y, p1.Z - view.getCamera().position.z);

Vector3F p_p2 = new Vector3F(p2.X - view.getCamera().position.x, p2.Y - view.getCamera().position.y, p2.Z - view.getCamera().position.z);

Vector3F p_p3 = new Vector3F(p3.X - view.getCamera().position.x, p3.Y - view.getCamera().position.y, p3.Z - view.getCamera().position.z);

Vector3F p_p4 = new Vector3F(p4.X - view.getCamera().position.x, p4.Y - view.getCamera().position.y, p4.Z - view.getCamera().position.z);

float e = 0.01f;

float[] color = { 1, 1, 1, 1 };

p_p1.Normalize();

p_p2.Normalize();

p_p3.Normalize();

p_p4.Normalize();

p1 += p_p1 * e;

p2 += p_p2 * e;

p3 += p_p3 * e;

p4 += p_p4 * e;

float[] points = { p1.X, p1.Y, p1.Z, p3.X, p3.Y, p3.Z, p2.X, p2.Y, p2.Z, p4.X, p4.Y, p4.Z, };

view.getRenderSys().drawMouseSelectRect(points, color);

}

public static void drawRotateCircles(Vector3F center, IView view, float coord_length, float[] circlexy, float[] circleyz, float[] circlexz, bool hardsel, Matrix3F rotmat)

{

ClientBridge.ClientRenderSys rendersys = view.getRenderSys();

float length = coord_length;

length = GetFakeLength(center, length, stdDist, view);

Vector3F coord_x = Matrix3F.Transform(rotmat, new Vector3F(1, 0, 0));

Vector3F coord_y = Matrix3F.Transform(rotmat, new Vector3F(0, 1, 0));

Vector3F coord_z = Matrix3F.Transform(rotmat, new Vector3F(0, 0, 1));

if (hardsel)

{

rendersys.pushSelectID(0);

}

drawCircle(center, coord_x, length, circleyz, rendersys); // 绘制垂直于x轴的圆

if (hardsel)

{

rendersys.pushSelectID(1);

}

drawCircle(center, coord_y, length, circlexz, rendersys); // 绘制垂直于y轴的圆

if (hardsel)

{

rendersys.pushSelectID(2);

}

drawCircle(center, coord_z, length, circlexy, rendersys); // 绘制垂直于z轴的圆

coord_x = length * coord_x + center;

coord_y = length * coord_y + center;

coord_z = length * coord_z + center;

float[] points = { center.X, center.Y, center.Z, // 0 o

coord_x.X, coord_x.Y, coord_x.Z, // 1 x

coord_y.X, coord_y.Y, coord_y.Z, // 2 y

coord_z.X, coord_z.Y, coord_z.Z, // 3 z

};

int[] indexsx = { 0, 1 };

int[] indexsy = { 0, 2 };

int[] indexsz = { 0, 3 };

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexsx, circleyz, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexsy, circlexz, true);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexsz, circlexy, true);

}

public static void renderCoordinate(Vector3F center, IView view, float[] colorx, float[] colory, float[] colorz, float[] colorxy, float[] coloryz, float[] colorxz, bool hardsel)

{

renderCoordinate(center, view, colorx, colory, colorz, colorxy, coloryz, colorxz, hardsel, Matrix3F.Identity);

}

public static void renderCoordinate(Vector3F center, IView view, float[] colorx, float[] colory, float[] colorz, float[] colorxy, float[] coloryz, float[] colorxz, bool hardsel, Matrix3F rotmat)

{

renderCoordinate(center, view, 10.0f, colorx, colory, colorz, colorxy, coloryz, colorxz, hardsel, rotmat);

}

public static void renderCoordinate(Vector3F center, IView view, float coord_length, float[] colorx, float[] colory, float[] colorz, float[] colorxy, float[] coloryz, float[] colorxz, bool hardsel, Matrix3F rotmat)

{

ClientBridge.ClientRenderSys rendersys = view.getRenderSys();

float length = coord_length;

length = GetFakeLength(center, length, stdDist, view);

float length1 = length / 2.0f;

Vector3F coord_x = center + Matrix3F.Transform(rotmat, new Vector3F(length, 0, 0));

Vector3F coord_y = center + Matrix3F.Transform(rotmat, new Vector3F(0, length, 0));

Vector3F coord_z = center + Matrix3F.Transform(rotmat, new Vector3F(0, 0, length));

Vector3F coord_xh = center + Matrix3F.Transform(rotmat, new Vector3F(length1, 0, 0));

Vector3F coord_yh = center + Matrix3F.Transform(rotmat, new Vector3F(0, length1, 0));

Vector3F coord_zh = center + Matrix3F.Transform(rotmat, new Vector3F(0, 0, length1));

Vector3F coord_xy = center + Matrix3F.Transform(rotmat, new Vector3F(length1, length1, 0));

Vector3F coord_xz = center + Matrix3F.Transform(rotmat, new Vector3F(length1, 0, length1));

Vector3F coord_yz = center + Matrix3F.Transform(rotmat, new Vector3F(0, length1, length1));

float[] points = { center.X , center.Y , center.Z , // 0 o

coord_x.X , coord_x.Y , coord_x.Z , // 1 x

coord_y.X , coord_y.Y , coord_y.Z , // 2 y

coord_z.X , coord_z.Y , coord_z.Z , // 3 z

coord_xh.X, coord_xh.Y, coord_xh.Z, // 4 x_h

coord_yh.X, coord_yh.Y, coord_yh.Z, // 5 y_h

coord_zh.X, coord_zh.Y, coord_zh.Z, // 6 z_h

coord_xy.X, coord_xy.Y, coord_xy.Z, // 7 x_y

coord_xz.X, coord_xz.Y, coord_xz.Z, // 8 x_z

coord_yz.X, coord_yz.Y, coord_yz.Z // 9 y_z

};

int[] indexs_x = { 0, 1 }; // x轴索引

int[] indexs_y = { 0, 2 }; // y轴索引

int[] indexs_z = { 0, 3 }; // z轴索引

int[] indexs_xy = { 4, 7, 5 }; // xy夹角索引

int[] indexs_xz = { 4, 8, 6 }; // xz夹角索引

int[] indexs_yz = { 5, 9, 6 }; // yz夹角索引

if (hardsel)

{

rendersys.pushSelectID(0);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_x, colorx, true);

if (hardsel)

{

rendersys.pushSelectID(1);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_y, colory, true);

if (hardsel)

{

rendersys.pushSelectID(2);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_z, colorz, true);

if (hardsel)

{

rendersys.pushSelectID(3);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xy, colorxy, true);

if (hardsel)

{

rendersys.pushSelectID(4);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_xz, colorxz, true);

if (hardsel)

{

rendersys.pushSelectID(5);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_yz, coloryz, true);

if (hardsel)

{

rendersys.pushSelectID(0);

}

RenderPyramid(coord_x, coord_x - center, length / 3, colorx, rendersys);

if (hardsel)

{

rendersys.pushSelectID(1);

}

RenderPyramid(coord_y, coord_y - center, length / 3, colory, rendersys);

if (hardsel)

{

rendersys.pushSelectID(2);

}

RenderPyramid(coord_z, coord_z - center, length / 3, colorz, rendersys);

}

public static void renderResizeCoordinate(ResizeDirection rd, Vector3F center, IView view, float[] colorx, float[] colory, float[] colorz, float[] colorxy, float[] coloryz, float[] colorxz, float[] colorxyz, bool hardsel)

{

renderResizeCoordinate(rd, center, 10.0f, view, colorx, colory, colorz, colorxy, coloryz, colorxz, colorxyz, hardsel);

}

public static void renderResizeCoordinate(ResizeDirection rd, Vector3F center, float coord_length, IView view, float[] colorx, float[] colory, float[] colorz, float[] colorxy, float[] coloryz, float[] colorxz, float[] colorxyz, bool hardsel)

{

ClientBridge.ClientRenderSys rendersys = view.getRenderSys();

float length = coord_length;

length = GetFakeLength(center, length, stdDist, view);

Vector3F coordx = center + new Vector3F(length, 0, 0);

Vector3F coordy = center + new Vector3F(0, length, 0);

Vector3F coordz = center + new Vector3F(0, 0, length);

float length1 = length * 2 / 3;

float length2 = length / 2;

float[] points = { center.X, center.Y, center.Z, // 0 o

center.X + length, center.Y, center.Z, // 1 x

center.X, center.Y + length, center.Z, // 2 y

center.X, center.Y,center.Z + length, // 3 z

center.X + length1, center.Y, center.Z, // 4 x_h

center.X, center.Y + length1, center.Z, // 5 y_h

center.X, center.Y, center.Z + length1, // 6 z_h

center.X + length2, center.Y, center.Z, //7

center.X, center.Y + length2, center.Z, //8

center.X, center.Y, center.Z + length2, //9

};

int[] indexs_x = { 0, 1 }; // x轴索引

int[] indexs_y = { 0, 2 }; // y轴索引

int[] indexs_z = { 0, 3 }; // z轴索引

int[] indexs_xyl = { 4, 5, 7, 8 };

int[] indexs_xzl = { 4, 6, 7, 9 };

int[] indexs_yzl = { 5, 6, 8, 9 };

int[] indexs_xz = { 4, 6, 7, 7, 6, 9 }; // xy夹角索引

int[] indexs_xy = { 4, 7, 5, 7, 8, 5 }; // xz夹角索引

int[] indexs_yz = { 9, 6, 8, 8, 6, 5 }; // yz夹角索引

int[] indexs_xyz = { 7, 9, 8 };

if (hardsel)

{

rendersys.pushSelectID(0);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_x, colorx, true);

if (hardsel)

{

rendersys.pushSelectID(1);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_y, colory, true);

if (hardsel)

{

rendersys.pushSelectID(2);

}

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_STRIP, points, indexs_z, colorz, true);

if (hardsel)

{

rendersys.pushSelectID(3);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xy, colorxy, true);

}

else

{

if (rd == ResizeDirection.RD_XY)

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xy, colorxy, true);

}

else

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexs_xyl, colorxy, true);

}

if (hardsel)

{

rendersys.pushSelectID(4);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xz, colorxz, true);

}

else

{

if (rd == ResizeDirection.RD_XZ)

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xz, colorxz, true);

}

else

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexs_xzl, colorxz, true);

}

if (hardsel)

{

rendersys.pushSelectID(5);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_yz, coloryz, true);

}

else

{

if (rd == ResizeDirection.RD_YZ)

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_yz, coloryz, true);

}

else

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_LINE_LIST, points, indexs_yzl, coloryz, true);

}

if (hardsel)

{

rendersys.pushSelectID(6);

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xyz, colorxyz, true);

}

else

{

if (rd == ResizeDirection.RD_XYZ)

{

rendersys.drawIndex(ClientBridge.IndexDrawType.LDT_TRIANGLE_LIST, points, indexs_xyz, colorxyz, true);

}

RenderPyramid(coordx, coordx - center, length / 3, colorx, rendersys);

RenderPyramid(coordy, coordy - center, length / 3, colory, rendersys);

RenderPyramid(coordz, coordz - center, length / 3, colorz, rendersys);

}

public static MoveDirection SelectMoveLines(Vector3F center, System.Drawing.Point point, IView view)

{

return SelectMoveLines(center, point, view, Matrix3F.Identity);

}

public static MoveDirection SelectMoveLines(Vector3F center, System.Drawing.Point point, IView view, Matrix3F rotmat)

{

return SelectMoveLines(center, point, view, 10.0f, rotmat);

}

public static MoveDirection SelectMoveLines(Vector3F center, System.Drawing.Point point, IView view, float length, Matrix3F rotmat)

{

view.setCamera();

view.getRenderSys().beginHardwareSelect(new int[] { point.X - Tool.SelLine_EdgeWidth, point.Y - Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth }, true);

renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Blue, Tool.White, Tool.White, Tool.White, true, rotmat);

uint[] res = view.getRenderSys().endHardwareSelect();

if (res != null && res.GetLength(0) > 0)

{

switch (res[0])

{

case 0:

return MoveDirection.MD_X;

case 1:

return MoveDirection.MD_Y;

case 2:

return MoveDirection.MD_Z;

case 3:

return MoveDirection.MD_XY;

case 4:

return MoveDirection.MD_XZ;

case 5:

return MoveDirection.MD_YZ;

default:

return MoveDirection.MD_NONE;

}

else

{

return MoveDirection.MD_NONE;

}

public static RotateDirection SelectRotateCircles(Vector3F center, System.Drawing.Point point, IView view)

{

return SelectRotateCircles(center, point, view, Matrix3F.Identity);

}

public static RotateDirection SelectRotateCircles(Vector3F center, System.Drawing.Point point, IView view, Matrix3F rotmat)

{

return SelectRotateCircles(center, point, 10.0f, view, rotmat);

}

public static RotateDirection SelectRotateCircles(Vector3F center, System.Drawing.Point point, float length, IView view, Matrix3F rotmat)

{

view.setCamera();

view.getRenderSys().beginHardwareSelect(new int[] { point.X - Tool.SelLine_EdgeWidth, point.Y - Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth }, true);

drawRotateCircles(center, view, length, Tool.Red, Tool.Green, Tool.Blue, true, rotmat);

uint[] res = view.getRenderSys().endHardwareSelect();

if (res != null && res.GetLength(0) > 0)

{

switch (res[0])

{

case 0:

return RotateDirection.RD_X;

case 1:

return RotateDirection.RD_Y;

case 2:

return RotateDirection.RD_Z;

default:

return RotateDirection.RD_NONE;

}

else

{

return RotateDirection.RD_NONE;

}

public static ResizeDirection SelectResizeDirection(Vector3F center, System.Drawing.Point point, IView view)

{

return SelectResizeDirection(center, point, 10.0f, view);

}

public static ResizeDirection SelectResizeDirection(Vector3F center, System.Drawing.Point point, float length, IView view)

{

view.setCamera();

view.getRenderSys().beginHardwareSelect(new int[] { point.X - Tool.SelLine_EdgeWidth, point.Y - Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth, 2 * Tool.SelLine_EdgeWidth }, true);

renderResizeCoordinate(ResizeDirection.RD_NONE, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.White, Tool.White, Tool.White, Tool.White, true);

uint[] res = view.getRenderSys().endHardwareSelect();

if (res != null && res.GetLength(0) > 0)

{

switch (res[0])

{

case 0:

return ResizeDirection.RD_X;

case 1:

return ResizeDirection.RD_Y;

case 2:

return ResizeDirection.RD_Z;

case 3:

return ResizeDirection.RD_XY;

case 4:

return ResizeDirection.RD_XZ;

case 5:

return ResizeDirection.RD_YZ;

case 6:

return ResizeDirection.RD_XYZ;

default:

return ResizeDirection.RD_NONE;

}

else

{

return ResizeDirection.RD_NONE;

}

//两个点相减求向量并归一化

public static Vector3F ComputeVectorAndNormalize(Vector3F start, Vector3F end)

{

Vector3F res = Vector3F.Subtract(end, start);

float length = (float)Math.Sqrt(res.X * res.X + res.Y * res.Y + res.Z * res.Z);

res.X /= length;

res.Y /= length;

res.Z /= length;

return res;

}

//求两个点之间的距离

public static float ComputeDisBetweenTwoPoint(Vector3F start, Vector3F end)

{

Vector3F res = Vector3F.Subtract(end, start);

return (float)Math.Sqrt(res.X * res.X + res.Y * res.Y + res.Z * res.Z);

}

//给定球心和半径，求顶点

private static void ComputePointVertex(Vector3F center, float radius, float[] points)

{

float da = (float)Math.PI / 5;

float cos_da = (float)Math.Cos(da);

float sin_da = (float)Math.Sin(da);

float dx1 = radius * (float)Math.Sin(Math.PI / 3);

float dy1 = 0;

float dx2 = radius;

float dy2 = 0;

float z1 = center.Z + radius / 2;

float z2 = center.Z - radius / 2;

points[0] = center.X;

points[1] = center.Y;

points[2] = center.Z + radius;

points[93] = center.X;

points[94] = center.Y;

points[95] = center.Z - radius;

for (int i = 0; i < 10; ++i)

{

int index = 3 * i;

// 点

points[index + 3] = dx1 * cos_da - dy1 * sin_da;

points[index + 4] = dx1 * sin_da + dy1 * cos_da;

dx1 = points[index + 3];

dy1 = points[index + 4];

points[index + 3] += center.X;

points[index + 4] += center.Y;

points[index + 5] = z1;

points[index + 33] = dx2 * cos_da - dy2 * sin_da;

points[index + 34] = dx2 * sin_da + dy2 * cos_da;

dx2 = points[index + 33];

dy2 = points[index + 34];

points[index + 33] += center.X;

points[index + 34] += center.Y;

points[index + 35] = center.Z;

points[index + 63] = points[index + 3];

points[index + 64] = points[index + 4];

points[index + 65] = z2;

}

public static void RenderMoveCoordinate(MoveDirection md, Vector3F center, IView view)

{

RenderMoveCoordinate(md, center, view, Matrix3F.Identity);

}

public static void RenderMoveCoordinate(MoveDirection md, Vector3F center, IView view, Matrix3F rotmat)

{

RenderMoveCoordinate(md, center, view, 10.0f, rotmat);

}

public static void RenderMoveCoordinate(MoveDirection md, Vector3F center, IView view, float length, Matrix3F rotmat)

{

switch (md)

{

case MoveDirection.MD_X:

RenderHelper.renderCoordinate(center, view, length, Tool.Yellow, Tool.Green, Tool.Blue, Tool.White, Tool.White, Tool.White, false, rotmat);

break;

case MoveDirection.MD_Y:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Yellow, Tool.Blue, Tool.White, Tool.White, Tool.White, false, rotmat);

break;

case MoveDirection.MD_Z:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Yellow, Tool.White, Tool.White, Tool.White, false, rotmat);

break;

case MoveDirection.MD_XY:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Blue, Tool.Yellow, Tool.White, Tool.White, false, rotmat);

break;

case MoveDirection.MD_XZ:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Blue, Tool.White, Tool.White, Tool.Yellow, false, rotmat);

break;

case MoveDirection.MD_YZ:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Blue, Tool.White, Tool.Yellow, Tool.White, false, rotmat);

break;

case MoveDirection.MD_NONE:

RenderHelper.renderCoordinate(center, view, length, Tool.Red, Tool.Green, Tool.Blue, Tool.White, Tool.White, Tool.White, false, rotmat);

break;

default:

break;

}

public static void RenderRotateCircles(RotateDirection rd, Vector3F center, IView view)

{

RenderRotateCircles(rd, center, view, Matrix3F.Identity);

}

public static void RenderRotateCircles(RotateDirection rd, Vector3F center, IView view, Matrix3F rotmat)

{

RenderRotateCircles(rd, 10.0f, center, view, rotmat);

}

public static void RenderRotateCircles(RotateDirection rd, float length, Vector3F center, IView view, Matrix3F rotmat)

{

switch (rd)

{

case RotateDirection.RD_X:

RenderHelper.drawRotateCircles(center, view, length, Tool.Blue, Tool.Yellow, Tool.Green, false, rotmat);

break;

case RotateDirection.RD_Y:

RenderHelper.drawRotateCircles(center, view, length, Tool.Blue, Tool.Red, Tool.Yellow, false, rotmat);

break;

case RotateDirection.RD_Z:

RenderHelper.drawRotateCircles(center, view, length, Tool.Yellow, Tool.Red, Tool.Green, false, rotmat);

break;

case RotateDirection.RD_NONE:

RenderHelper.drawRotateCircles(center, view, length, Tool.Blue, Tool.Red, Tool.Green, false, rotmat);

break;

default:

RenderHelper.drawRotateCircles(center, view, length, Tool.Blue, Tool.Red, Tool.Green, false, rotmat);

break;

}

public static void RenderResizeCoordinate(ResizeDirection rd, Vector3F center, IView view)

{

RenderResizeCoordinate(rd, center, 10.0f, view);

}

public static void RenderResizeCoordinate(ResizeDirection rd, Vector3F center, float length, IView view)

{

switch (rd)

{

case ResizeDirection.RD_X:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Yellow, Tool.Green, Tool.Blue, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Yellow, false);

break;

case ResizeDirection.RD_Y:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Yellow, Tool.Blue, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Yellow, false);

break;

case ResizeDirection.RD_Z:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Yellow, false);

break;

case ResizeDirection.RD_XY:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.Purple, Tool.Yellow, Tool.Yellow, Tool.Yellow, false);

break;

case ResizeDirection.RD_XZ:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.Yellow, Tool.Yellow, Tool.Purple, Tool.Yellow, false);

break;

case ResizeDirection.RD_YZ:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.Yellow, Tool.Purple, Tool.Yellow, Tool.Yellow, false);

break;

case ResizeDirection.RD_XYZ:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Purple, false);

break;

case ResizeDirection.RD_NONE:

RenderHelper.renderResizeCoordinate(rd, center, length, view, Tool.Red, Tool.Green, Tool.Blue, Tool.Yellow, Tool.Yellow, Tool.Yellow, Tool.Yellow, false);

break;

default:

break;

}

public static void Draw2DViewRect(int x1, int y1, int x2, int y2, IView view)