public BrickShader(GraphicsInterface gi)
: base(gi)
{
//Console.WriteLine("BrickShader Link Log: \n{0}", InfoLog);
GLSLVertexShader vShader = new GLSLVertexShader(gi, Brick_VertexSource);
AttachShader(vShader);
GLSLFragmentShader fShader = new GLSLFragmentShader(gi, Brick_FragmentSource);
AttachShader(fShader);
Link();
// Do an initial selection so that all the variables can be located
Bind();
BrickColor_Pos = GetUniformLocation("BrickColor");
MortarColor_Pos = GetUniformLocation("MortarColor");
BrickSize_Pos = GetUniformLocation("BrickSize");
BrickPct_Pos = GetUniformLocation("BrickPct");
// From the Vertex Shader
LightPosition_Pos = GetUniformLocation("LightPosition");
// Set some initial values
BrickColor = new ColorRGBA(1.0f, 0.3f, 0.2f);
MortarColor = new ColorRGBA(0.85f, 0.86f, 0.84f);
BrickSize = new float2(0.30f, 0.15f);
BrickPct = new float2(0.90f, 0.85f);
LightPosition = new Vector3f(0.0f, 0.0f, 4.0f);
// Unselect so we start in an unselected state
Unbind();
}
public int Raycast(Ray ray, uint[] triangles, Vector3f[] vertices, List<int> triangleMap)
{
double closestDist = double.MaxValue;
int closestHit = -1;
for (int i = 0; i < triangles.Length; i += 3)
{
Vector3 p0 = (Vector3)vertices[triangles[i+0]];
Vector3 p1 = (Vector3)vertices[triangles[i+1]];
Vector3 p2 = (Vector3)vertices[triangles[i+2]];
Plane plane = new Plane(p0, p1, p2);
//Console.WriteLine(i+" "+plane);
double dist;
if (plane.Raycast(ray, out dist))
{
Vector3 hitPoint = ray.origin+ray.direction*dist;
Vector3 bary = MathUtil.Barycentric(p0, p1, p2, hitPoint);
if (MathUtil.BarycentricIsInside(bary))
{
if (dist < closestDist)
{
closestDist = dist;
closestHit = triangleMap[i/3];
}
}
}
}
return closestHit;
}
public Vector4f(Vector3f source, float w)
{
X = source.X;
Y = source.Y;
Z = source.Z;
W = w;
}
internal Bone(string name, int parent, ImmutableArray<int> boneControllers,
Vector3f position, Quaternionf quaternion, Vector3f rotation, Vector3f positionScale, Vector3f rotationScale,
Matrix4x4f poseToBone, Quaternionf alignment,
int flags, int procType, int procIndex, int physicsBone, int surfacePropIdx, int contents)
{
Name = name;
Parent = parent;
BoneControllers = boneControllers;
Position = position;
Quaternion = quaternion;
Rotation = rotation;
PositionScale = positionScale;
RotationScale = rotationScale;
PoseToBone = poseToBone;
Alignment = alignment;
Flags = flags;
ProcType = procType;
ProcIndex = procIndex;
PhysicsBone = physicsBone;
SurfacePropIdx = surfacePropIdx;
Contents = contents;
}
public Cylinder3f( Vector3f origin, Vector3f axis, float radius, float height )
{
this.origin = origin;
this.axis = axis;
this.radius = radius;
this.height = height;
}
public static Vector4f ExtractBackgroundColor( Vector4f composite, Vector4f foreground )
{
// c = composite, f = foreground, b = background
// red channel:
// c_r = f_a * f_r + ( 1 - f_a ) * b_r
// ==> b_r = ( c_r - f_a * f_r ) / ( 1 - f_a )
//
// alpha channel:
// c_a = f_a + b_a * ( 1 - f_a )
// ==> b_a = ( c_a - f_a ) / ( 1 - f_a )
Vector3f compositeRGB = composite.XYZ;
Vector3f foregroundRGB = foreground.XYZ;
float ca = composite.w;
float fa = foreground.w;
if( fa > 0 && fa < 1 ) // partially transparent
{
var backgroundRGB = new Vector3f( compositeRGB - fa * foregroundRGB ) / ( 1.0f - fa );
var ba = ( ca - fa ) / ( 1 - fa );
return new Vector4f( backgroundRGB, ba ).Saturate();
}
else if( fa < 0.5f ) // foreground is fully transparent: background = input
{
return composite;
}
else // fa == 1, foreground is completely opaque, have no idea what the background is, return opaque black
{
// return new Vector4f( 0, 0, 0, 1 );
return Vector4f.Zero;
}
}
public MDXSubmesh(byte[] data)
{
using (MemoryStream ms = new MemoryStream(data))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.PartID = br.ReadUInt32();
this.StartVertexIndex = br.ReadUInt16();
this.VertexCount = br.ReadUInt16();
this.StartTriangleIndex = br.ReadUInt16();
this.TriangleCount = br.ReadUInt16();
this.BoneCount = br.ReadUInt16();
this.StartBoneIndex = br.ReadUInt16();
this.InfluencingBonesIndex = br.ReadUInt16();
this.RootBoneIndex = br.ReadUInt16();
this.SubmeshMedianPoint = br.ReadVector3f();
if (br.BaseStream.Length > 32)
{
this.BoundingShellMedianPoint = br.ReadVector3f();
this.BoundingSphereRadius = br.ReadSingle();
}
}
}
}
private void Load(Stream stream)
{
BinaryReader reader = new BinaryReader(stream, Encoding.ASCII);
if (reader.ReadInt32() != 16)
throw new InvalidDataException("File header is not 16.");
Id = reader.ReadInt32();
int solids = reader.ReadInt32();
Checksum = reader.ReadInt32();
for (int i = 0; i < solids; ++i)
{
int solidSize = reader.ReadInt32();
string vphysics = Encoding.ASCII.GetString(reader.ReadBytes(4));
int version = reader.ReadUInt16();
int modelType = reader.ReadUInt16();
int surfaceSize = reader.ReadInt32();
Vector3f dragAxisAreas = new Vector3f(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
int axisMapSize = reader.ReadInt32();
if (vphysics == "VPHY")
{
}
}
}
public void OnUpdate()
{
if (mesh)
{
mesh.Dispose();
}
Rect rect = rectTransform.rect;
positionVboData[0] = new Vector3f((float)rect.min.X, (float)rect.min.Y, 0);
positionVboData[1] = new Vector3f((float)rect.min.X, (float)rect.max.Y, 0);
positionVboData[2] = new Vector3f((float)rect.max.X, (float)rect.max.Y, 0);
positionVboData[3] = new Vector3f((float)rect.max.X, (float)rect.min.Y, 0);
mesh = new Mesh();
mesh.AddBuffer<VertexBufferObject3f>("vertex");
mesh.SetBuffer3f("vertex", positionVboData);
mesh.AddBuffer<VertexBufferObject3f>("normal");
mesh.SetBuffer3f("normal", normalVboData);
mesh.AddBuffer<VertexBufferObject2f>("uv0");
mesh.SetBuffer2f("uv0", uvVboData);
mesh.SetIndices(indicesVboData, 0, Graphics.PrimitiveType.Triangles);
MeshRenderer meshRenderer = sceneObject.GetModule<MeshRenderer>();
if (meshRenderer)
{
meshRenderer.mesh = mesh;
}
}
public static Vector3f CrossProduct(Vector3f left, Vector3f right)
{
return new Vector3f(
left.Y * right.Z - left.Z * right.Y,
left.Z * right.X - left.X * right.Z,
left.X * right.Y - left.Y * right.X);
}
//Mouse drag, calculate rotation
public void drag(Point NewPt, Quat4f NewRot)
{
//Map the point to the sphere
this.mapToSphere(NewPt, EnVec);
//Return the quaternion equivalent to the rotation
if (NewRot != null)
{
Vector3f Perp = new Vector3f();
//Compute the vector perpendicular to the begin and end vectors
Vector3f.cross(Perp, StVec, EnVec);
//Compute the length of the perpendicular vector
if (Perp.length() > Epsilon) //if its non-zero
{
//We're ok, so return the perpendicular vector as the transform after all
NewRot.x = Perp.x;
NewRot.y = Perp.y;
NewRot.z = Perp.z;
//In the quaternion values, w is cosine (theta / 2), where theta is rotation angle
NewRot.w = Vector3f.dot(StVec, EnVec);
}
else //if its zero
{
//The begin and end vectors coincide, so return an identity transform
NewRot.x = NewRot.y = NewRot.z = NewRot.w = 0.0f;
}
}
}
public static Matrix3f RotateAxis( Vector3f axis, float radians )
{
var normalizedAxis = axis.Normalized();
float cosTheta = ( float )( Math.Cos( radians ) );
float sinTheta = ( float )( Math.Sin( radians ) );
float x = normalizedAxis.x;
float y = normalizedAxis.y;
float z = normalizedAxis.z;
var m = new Matrix3f();
m[ 0, 0 ] = x * x * ( 1.0f - cosTheta ) + cosTheta;
m[ 0, 1 ] = y * x * ( 1.0f - cosTheta ) - z * sinTheta;
m[ 0, 2 ] = z * x * ( 1.0f - cosTheta ) + y * sinTheta;
m[ 1, 0 ] = x * y * ( 1.0f - cosTheta ) + z * sinTheta;
m[ 1, 1 ] = y * y * ( 1.0f - cosTheta ) + cosTheta;
m[ 1, 2 ] = z * y * ( 1.0f - cosTheta ) - x * sinTheta;
m[ 2, 0 ] = x * z * ( 1.0f - cosTheta ) - y * sinTheta;
m[ 2, 1 ] = y * z * ( 1.0f - cosTheta ) + x * sinTheta;
m[ 2, 2 ] = z * z * ( 1.0f - cosTheta ) + cosTheta;
return m;
}
public static Matrix3f RotateBetween( Vector3f from, Vector3f to )
{
from.Normalize();
to.Normalize();
var crossProduct = Vector3f.Cross( from, to );
var normalizedAxis = crossProduct.Normalized();
float sinTheta = crossProduct.Norm();
float cosTheta = Vector3f.Dot( from, to );
float x = normalizedAxis.x;
float y = normalizedAxis.y;
float z = normalizedAxis.z;
var m = new Matrix3f();
m[ 0, 0 ] = x * x * ( 1.0f - cosTheta ) + cosTheta;
m[ 0, 1 ] = y * x * ( 1.0f - cosTheta ) - z * sinTheta;
m[ 0, 2 ] = z * x * ( 1.0f - cosTheta ) + y * sinTheta;
m[ 1, 0 ] = x * y * ( 1.0f - cosTheta ) + z * sinTheta;
m[ 1, 1 ] = y * y * ( 1.0f - cosTheta ) + cosTheta;
m[ 1, 2 ] = z * y * ( 1.0f - cosTheta ) - x * sinTheta;
m[ 2, 0 ] = x * z * ( 1.0f - cosTheta ) - y * sinTheta;
m[ 2, 1 ] = y * z * ( 1.0f - cosTheta ) + x * sinTheta;
m[ 2, 2 ] = z * z * ( 1.0f - cosTheta ) + cosTheta;
return m;
}
/// <summary>
/// 绘制风扇
/// </summary>
/// <param name="dxf"></param>
/// <param name="startPoint">风扇起点，如果为横置，由左向右；如果为竖置，由下到上</param>
/// <param name="endPoint">风扇终点，如果为横置，由左向右；如果为竖置，由下到上</param>
/// <param name="pointerLocation">箭头位置，默认=0为无，=1代表箭头在中间，=2代表箭头在底部</param>
public static void Draw(DxfDocument dxf, Vector3f startPoint, Vector3f endPoint,int pointerLocation=0)
{
Layer layer = new Layer("line");
Line line = new Line(startPoint, endPoint);
line.Layer = layer;
dxf.AddEntity(line);
//如果为横置
if (startPoint.Y == endPoint.Y)
{
float segment = (endPoint.X - startPoint.X) / 4;
Slash.Draw(dxf, new Location(startPoint.X + segment, startPoint.Y, startPoint.Z));
Slash.Draw(dxf, new Location(startPoint.X + 2 * segment, startPoint.Y, startPoint.Z));
Slash.Draw(dxf, new Location(startPoint.X + 3 * segment, startPoint.Y, startPoint.Z));
}
//如果为竖置
else if (startPoint.X == endPoint.X)
{
float segment = (endPoint.Y - startPoint.Y) / 5;
Slash.Draw(dxf, new Location(startPoint.X, startPoint.Y + segment, startPoint.Z));
Slash.Draw(dxf, new Location(startPoint.X, startPoint.Y + 2 * segment, startPoint.Z));
Slash.Draw(dxf, new Location(startPoint.X, startPoint.Y + 3 * segment, startPoint.Z));
Slash.Draw(dxf, new Location(startPoint.X, startPoint.Y + 4 * segment, startPoint.Z));
if (pointerLocation == 1)
{
LinePointer.Draw(dxf,new Location(startPoint.X,(startPoint.Y+endPoint.Y)/2,startPoint.Z));
}
else if(pointerLocation==2)
{
LinePointer.Draw(dxf, new Location(startPoint.X, startPoint.Y, startPoint.Z));
}
}
}
public void SetVertices(Vector3f[] verts)
{
if (fVertexBufferObject != null)
{
fVertexBufferObject.Dispose();
fVertexBufferObject = null;
}
// Write the vertex data to the buffer
GCHandle dataPtr = GCHandle.Alloc(verts, GCHandleType.Pinned);
int dataSize = Marshal.SizeOf(typeof(Vector3f)) * verts.Length;
fVertexBufferObject = new VertexBufferObject(GI);
fVertexBufferObject.Bind();
fVertexBufferObject.Size = dataSize;
try
{
fVertexBufferObject.Bind();
fVertexBufferObject.Write(dataPtr.AddrOfPinnedObject(), 0, dataSize);
}
finally
{
fVertexBufferObject.Unbind();
dataPtr.Free();
}
}
public void SetParameter(string Parameter, Vector3f[] vec3array)
{
for (int i = 0; i < vec3array.Length; i++)
{
this.SetParameter(Parameter + i, vec3array[i]);
}
}
public Transformation ()
{
translation = new Vector3f(0,0,0);
scale = new Vector3f(1,1,1);
rotation = Matrix3f.Identity();
transformation = Matrix4f.Identity();
}
public static bool SolidSphereHollowBox( Vector3f sphereCenter, float sphereRadius,
Vector3f boxCorner, Vector3f boxSize )
{
float dmin = 0;
var boxMax = boxCorner + boxSize;
bool face = false;
for( int i = 0; i < 3; ++i )
{
if( sphereCenter[ i ] < boxCorner[ i ] )
{
face = true;
dmin += ( sphereCenter[ i ] - boxCorner[ i ] ) * ( sphereCenter[ i ] - boxCorner[ i ] );
}
else if( sphereCenter[ i ] > boxMax[ i ] )
{
face = true;
dmin += ( sphereCenter[ i ] - boxMax[ i ] ) * ( sphereCenter[ i ] - boxMax[ i ] );
}
else if( sphereCenter[ i ] - boxCorner[ i ] <= sphereRadius )
{
face = true;
}
else if( boxMax[ i ] - sphereCenter[ i ] <= sphereRadius )
{
face = true;
}
}
return ( face && ( dmin <= sphereRadius * sphereRadius ) );
}
public void LoadBinaryData(byte[] inData)
{
using (MemoryStream ms = new MemoryStream(inData))
{
using (BinaryReader br = new BinaryReader(ms))
{
this.WidthVertices = br.ReadUInt32();
this.HeightVertices = br.ReadUInt32();
this.WidthTileFlags = br.ReadUInt32();
this.HeightTileFlags = br.ReadUInt32();
this.Location = br.ReadVector3f();
this.MaterialIndex = br.ReadUInt16();
uint vertexCount = this.WidthVertices * this.HeightVertices;
for (int i = 0; i < vertexCount; ++i)
{
this.LiquidVertices.Add(new LiquidVertex(br.ReadBytes(LiquidVertex.GetSize())));
}
uint tileFlagCount = this.WidthTileFlags * this.HeightTileFlags;
for (int i = 0; i < tileFlagCount; ++i)
{
this.LiquidTileFlags.Add((LiquidFlags)br.ReadByte());
}
}
}
}
public void mapToSphere(Point point, Vector3f vector)
{
//Copy paramter into temp point
Point2f tempPoint = new Point2f(point.X, point.Y);
//Adjust point coords and scale down to range of [-1 ... 1]
tempPoint.x = (tempPoint.x * this.adjustWidth) - 1.0f;
tempPoint.y = 1.0f - (tempPoint.y * this.adjustHeight);
//Compute the square of the length of the vector to the point from the center
float length = (tempPoint.x * tempPoint.x) + (tempPoint.y * tempPoint.y);
//If the point is mapped outside of the sphere... (length > radius squared)
if (length > 1.0f)
{
//Compute a normalizing factor (radius / sqrt(length))
float norm = (float) (1.0 / Math.Sqrt(length));
//Return the "normalized" vector, a point on the sphere
vector.x = tempPoint.x * norm;
vector.y = tempPoint.y * norm;
vector.z = 0.0f;
}
else //Else it's on the inside
{
//Return a vector to a point mapped inside the sphere sqrt(radius squared - length)
vector.x = tempPoint.x;
vector.y = tempPoint.y;
vector.z = (float) Math.Sqrt(1.0f - length);
}
}
// TODO: get rid of ComputeProjectionMatrix()
public Camera( Vector3f position, Vector3f forward, Vector3f up,
float fovYDegrees,
int screenWidth, int screenHeight )
{
FieldOfView = Arithmetic.DegreesToRadians( fovYDegrees );
// interpolationKeyFrames = new KeyFrameInterpolator
Frame = new ManipulatedCameraFrame();
SceneRadius = 1.0f;
orthoCoeff = ( float ) ( Math.Tan( FieldOfView / 2.0 ) );
SceneCenter = Vector3f.Zero;
CameraType = CameraType.PERSPECTIVE;
ZNearCoefficient = 0.005f;
ZClippingCoefficient = ( float ) ( Math.Sqrt( 3.0 ) );
// dummy values
screenSize = new Vector2i( screenWidth, screenHeight );
Position = position;
UpVector = up;
ViewDirection = forward;
ComputeViewMatrix();
ComputeProjectionMatrix();
}
public Vector3f AddStore(Vector3f other)
{
this.x += other.x;
this.y += other.y;
this.z += other.z;
return this;
}
private bool WithinArea(Vector3f location)
{
var differenceFromCenter = this.Position - location;
var uLength = Util.Projection(differenceFromCenter, uDirection);
var vLength = Util.Projection(differenceFromCenter, vDirection);
return uLength.Magnitude() <= width / 2f && vLength.Magnitude() <= height / 2f;
}
public void SetTranslationAndRotation( Vector3f translation, Quat4f rotation )
{
this.t_ = translation;
this.q_ = rotation;
// TODO:
// emit modified
}
public VertexPosition3fNormal3fTexture2fColor4ub( Vector3f position, Vector3f normal,
Vector2f uv, Vector4ub color )
{
this.position = position;
this.normal = normal;
this.textureCoordinates = uv;
this.color = color;
}
public Vector3f Add(Vector3f other)
{
Vector3f res = new Vector3f();
res.x = this.x + other.x;
res.y = this.y + other.y;
res.z = this.z + other.z;
return res;
}
public Vertex(int tIndex, Vector3f tPosition)
{
index = tIndex;
position = tPosition;
connectedEdges = new List<Edge>();
connectedFaces = new List<Face>();
edgesAndFacesSorted = false;
}
public VertexPosition3fNormal3fTexture2f( float x, float y, float z,
float nx, float ny, float nz,
float u, float v )
{
position = new Vector3f( x, y, z );
normal = new Vector3f( nx, ny, nz );
textureCoordinates = new Vector2f( u, v );
}
internal Vertex(ImmutableArray<BoneWeight> boneWeights,
Vector3f position, Vector3f normal, Vector2f textureCoordinates, Vector4f tangent)
{
BoneWeights = boneWeights;
Position = position;
Normal = normal;
TextureCoordinates = textureCoordinates;
Tangent = tangent;
}
/// <summary>
/// Initializes a new instance of the <c>Polyline3dVertex</c> class.
/// </summary>
/// <param name="location">Polyline <see cref="Vector3f">vertex</see> coordinates.</param>
public Polyline3dVertex(Vector3f location)
: base(DxfObjectCode.Vertex)
{
this.flags = VertexTypeFlags.Polyline3dVertex;
this.location = location;
this.layer = Layer.Default;
this.color = AciColor.ByLayer;
this.lineType = LineType.ByLayer;
}
public void SetRotation(Vector3f rotation)
{
Rotation = rotation;
CalculateRotationMatrix();
}
public Element RayTrace(Vector3f origin, Vector3f direction, float maxDistance)
{
return(null);
}
/// <summary>
/// Load this instance from the <see cref="System.String"/> representation.
/// </summary>
/// <param name="value">The <see cref="System.String"/> value to convert.</param>
void ILoadFromString.FromString(string value)
{
string[] parts = value.Trim('[', ']').Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
Row0 = Vector3f.Parse(parts[0]);
Row1 = Vector3f.Parse(parts[1]);
}
public virtual void formatMeasurement()
{
for (int i = count; --i >= 0;)
{
if (countPlusIndices[i + 1] < 0)
{
strMeasurement = null;
return;
}
}
if (count < 2)
{
return;
}
switch (count)
{
case 2:
float distance = frame.getDistance(countPlusIndices[1], countPlusIndices[2]);
strMeasurement = formatDistance(distance);
break;
case 3:
float degrees = frame.getAngle(countPlusIndices[1], countPlusIndices[2], countPlusIndices[3]);
strMeasurement = formatAngle(degrees);
if (degrees == 180)
{
aa = null;
pointArc = null;
}
else
{
Point3f pointA = getAtomPoint3f(1);
Point3f pointB = getAtomPoint3f(2);
Point3f pointC = getAtomPoint3f(3);
Vector3f vectorBA = new Vector3f();
Vector3f vectorBC = new Vector3f();
vectorBA.sub(pointA, pointB);
vectorBC.sub(pointC, pointB);
float radians = vectorBA.angle(vectorBC);
Vector3f vectorAxis = new Vector3f();
vectorAxis.cross(vectorBA, vectorBC);
aa = new AxisAngle4f(vectorAxis.x, vectorAxis.y, vectorAxis.z, radians);
vectorBA.normalize();
vectorBA.scale(0.5f);
pointArc = new Point3f(vectorBA);
}
break;
case 4:
float torsion = frame.getTorsion(countPlusIndices[1], countPlusIndices[2], countPlusIndices[3], countPlusIndices[4]);
strMeasurement = formatAngle(torsion);
break;
default:
System.Console.Out.WriteLine("Invalid count to measurement shape:" + count);
throw new System.IndexOutOfRangeException();
}
}
public void ModifyAttachedCP(Vector3f vec, Angle angle)
{
AttachedCPData = new Tuple <Vector3f, Angle>(vec, angle);
}
///<summary>
/// Gets the extreme point of the shape in world space in a given direction.
///</summary>
///<param name="direction">Direction to find the extreme point in.</param>
/// <param name="shapeTransform">Transform to use for the shape.</param>
///<param name="extremePoint">Extreme point on the shape.</param>
public void GetExtremePointWithoutMargin(Vector3f direction, ref RigidTransform shapeTransform, out Vector3f extremePoint)
{
Quaternion conjugate;
Quaternion.Conjugate(ref shapeTransform.Orientation, out conjugate);
Vector3f.Transform(ref direction, ref conjugate, out direction);
GetLocalExtremePointWithoutMargin(ref direction, out extremePoint);
Vector3f.Transform(ref extremePoint, ref shapeTransform.Orientation, out extremePoint);
Vector3f.Add(ref extremePoint, ref shapeTransform.Position, out extremePoint);
}
public void SetPosition(Vector3f position)
{
Position = position;
CalculateTranslationMatrix();
}
///<summary> /// Gets the extreme point of the shape in local space in a given direction. ///</summary> ///<param name="direction">Direction to find the extreme point in.</param> ///<param name="extremePoint">Extreme point on the shape.</param> public abstract void GetLocalExtremePointWithoutMargin(ref Vector3f direction, out Vector3f extremePoint);
public static extern Bool ovrp_SetOverlayQuad(Bool onTop, IntPtr texture, IntPtr device, Posef pose, Vector3f scale);
public static bool SetOverlayQuad(bool onTop, bool headLocked, IntPtr texture, IntPtr device, Posef pose, Vector3f scale)
{
if (version >= v0110)
{
return(OVRP0110.ovrp_SetOverlayQuad2(ToBool(onTop), ToBool(headLocked), texture, device, pose, scale) == Bool.True);
}
else
{
return(OVRP0100.ovrp_SetOverlayQuad(ToBool(onTop), texture, device, pose, scale) == Bool.True);
}
}
private AnimatorStateMachine(AssetInfo assetInfo, AnimatorController controller, int stateMachineIndex) :
base(assetInfo, 1)
{
VirtualSerializedFile virtualFile = (VirtualSerializedFile)assetInfo.File;
LayerConstant layer = controller.Controller.GetLayerByStateMachineIndex(stateMachineIndex);
Name = controller.TOS[layer.Binding];
StateMachineConstant stateMachine = controller.Controller.StateMachineArray[stateMachineIndex].Instance;
int stateCount = stateMachine.StateConstantArray.Count;
int stateMachineCount = 0;
int count = stateCount + stateMachineCount;
int side = (int)Math.Ceiling(Math.Sqrt(count));
List <AnimatorState> states = new List <AnimatorState>();
m_childStates = new ChildAnimatorState[stateCount];
for (int y = 0, stateIndex = 0; y < side && stateIndex < stateCount; y++)
{
for (int x = 0; x < side && stateIndex < stateCount; x++, stateIndex++)
{
Vector3f position = new Vector3f(x * StateOffset, y * StateOffset, 0.0f);
AnimatorState state = AnimatorState.CreateVirtualInstance(virtualFile, controller, stateMachineIndex, stateIndex, position);
ChildAnimatorState childState = new ChildAnimatorState(state, position);
m_childStates[stateIndex] = childState;
states.Add(state);
}
}
m_childStateMachines = new ChildAnimatorStateMachine[stateMachineCount];
// set destination state for transitions here because all states has become valid only now
for (int i = 0; i < stateMachine.StateConstantArray.Count; i++)
{
AnimatorState state = states[i];
StateConstant stateConstant = stateMachine.StateConstantArray[i].Instance;
for (int j = 0; j < stateConstant.TransitionConstantArray.Count; j++)
{
long stateTransitionPath = state.Transitions[j].PathID;
AnimatorStateTransition transition = (AnimatorStateTransition)virtualFile.GetAsset(stateTransitionPath);
TransitionConstant transitionConstant = stateConstant.TransitionConstantArray[j].Instance;
if (!transitionConstant.IsExit)
{
AnimatorState destState = states[transitionConstant.DestinationState];
transition.DstState = destState.File.CreatePPtr(destState);
}
}
}
m_anyStateTransitions = new PPtr <AnimatorStateTransition> [stateMachine.AnyStateTransitionConstantArray.Count];
for (int i = 0; i < stateMachine.AnyStateTransitionConstantArray.Count; i++)
{
TransitionConstant transitionConstant = stateMachine.AnyStateTransitionConstantArray[i].Instance;
AnimatorStateTransition transition = AnimatorStateTransition.CreateVirtualInstance(virtualFile, controller, transitionConstant, states);
m_anyStateTransitions[i] = transition.File.CreatePPtr(transition);
}
m_entryTransitions = stateMachine.GetEntryTransitions(virtualFile, controller, layer.Binding, states);
m_stateMachineBehaviours = new PPtr <MonoBehaviour> [0];
AnyStatePosition = new Vector3f(0.0f, -StateOffset, 0.0f);
EntryPosition = new Vector3f(StateOffset, -StateOffset, 0.0f);
ExitPosition = new Vector3f(2.0f * StateOffset, -StateOffset, 0.0f);
ParentStateMachinePosition = new Vector3f(0.0f, -2.0f * StateOffset, 0.0f);
DefaultState = ChildStates.Count > 0 ? ChildStates[stateMachine.DefaultState].State : default;
}
public float DotProduct(Vector3f v)
{
return(x * v.x + y * v.y + z * v.z);
}
public Vector3f Multiply(Vector3f v)
{
return(Multiply(v.x, v.y, v.z));
}
public void SetScale(Vector3f scale)
{
Scale = scale;
CalculateScaleMatrix();
}
/// <summary>
/// Computes a bounding box for the shape and expands it.
/// </summary>
/// <param name="transform">Transform to use to position the shape.</param>
/// <param name="sweep">Extra to add to the bounding box.</param>
/// <param name="boundingBox">Expanded bounding box.</param>
public void GetSweptBoundingBox(ref RigidTransform transform, ref Vector3f sweep, out BoundingBox boundingBox)
{
GetBoundingBox(ref transform, out boundingBox);
Toolbox.ExpandBoundingBox(ref boundingBox, ref sweep);
}
static extern void sfSoundStream_setPosition(IntPtr SoundStream, Vector3f position);
///<summary>
/// Gets the extreme point of the shape in world space in a given direction with margin expansion.
///</summary>
///<param name="direction">Direction to find the extreme point in.</param>
/// <param name="shapeTransform">Transform to use for the shape.</param>
///<param name="extremePoint">Extreme point on the shape.</param>
public void GetExtremePoint(Vector3f direction, ref RigidTransform shapeTransform, out Vector3f extremePoint)
{
GetExtremePointWithoutMargin(direction, ref shapeTransform, out extremePoint);
float directionLength = direction.LengthSquared;
if (directionLength > MathHelper.Epsilon)
{
Vector3f.Multiply(ref direction, collisionMargin / (float)Math.Sqrt(directionLength), out direction);
Vector3f.Add(ref extremePoint, ref direction, out extremePoint);
}
}
static public _OdGe.Vector3d ToHost(this Vector3f p)
{
return(new _OdGe.Vector3d(p.X, p.Y, p.Z));
}
/// <summary>
/// If go has a MeshFilter, extract it and append to SimpleMesh.
/// Returns false if no filter.
/// </summary>
bool AppendGOMesh(GameObject go, SimpleMesh m, int[] vertexMap, FScene scene, int gid)
{
MeshFilter filter = go.GetComponent <MeshFilter>();
if (filter == null || filter.mesh == null)
{
return(false);
}
Mesh curMesh = filter.sharedMesh;
Vector3[] vertices = curMesh.vertices;
Vector3[] normals = (WriteNormals) ? curMesh.normals : null;
Color[] colors = (WriteVertexColors) ? curMesh.colors : null;
Vector2[] uvs = (WriteUVs) ? curMesh.uv : null;
if (vertexMap.Length < curMesh.vertexCount)
{
vertexMap = new int[curMesh.vertexCount * 2];
}
for (int i = 0; i < curMesh.vertexCount; ++i)
{
NewVertexInfo vi = new NewVertexInfo();
vi.bHaveN = WriteNormals; vi.bHaveC = WriteVertexColors; vi.bHaveUV = WriteUVs;
Vector3f v = vertices[i];
// local to world
v = filter.gameObject.transform.TransformPoint(v);
// world back to scene
v = scene.ToSceneP(v);
vi.v = MeshTransforms.FlipLeftRightCoordSystems(vi.v);
if (WriteNormals)
{
Vector3 n = normals[i];
n = filter.gameObject.transform.TransformDirection(n); // to world
n = scene.ToSceneN(n); // to scene
vi.n = MeshTransforms.FlipLeftRightCoordSystems(vi.n);
}
if (WriteVertexColors)
{
vi.c = colors[i];
}
if (WriteUVs)
{
vi.uv = uvs[i];
}
vertexMap[i] = m.AppendVertex(vi);
}
int[] triangles = curMesh.triangles;
int nTriangles = triangles.Length / 3;
for (int i = 0; i < nTriangles; ++i)
{
int a = vertexMap[triangles[3 * i]];
int b = vertexMap[triangles[3 * i + 1]];
int c = vertexMap[triangles[3 * i + 2]];
m.AppendTriangle(a, c, b, gid); // TRI ORIENTATION IS REVERSED HERE!!
}
return(true);
}
public void ModifyAttachedCP(DeepPointer ptr, Vector3f vec, Angle angle)
{
AttachedCPData = new CPData {
CP_Pointer = ptr, SpawnPos = vec, SpawnAngle = angle
};;
}
/// <summary>
/// Gets the bounding box of the convex shape transformed first into world space, and then into the local space of another affine transform.
/// </summary>
/// <param name="shapeTransform">Transform to use to put the shape into world space.</param>
/// <param name="spaceTransform">Used as the frame of reference to compute the bounding box.
/// In effect, the shape is transformed by the inverse of the space transform to compute its bounding box in local space.</param>
/// <param name="sweep">Vector to expand the bounding box with in local space.</param>
/// <param name="boundingBox">Bounding box in the local space.</param>
public void GetSweptLocalBoundingBox(ref RigidTransform shapeTransform, ref AffineTransform spaceTransform, ref Vector3f sweep, out BoundingBox boundingBox)
{
GetLocalBoundingBox(ref shapeTransform, ref spaceTransform, out boundingBox);
Vector3f expansion;
Vector3f.TransformTranspose(ref sweep, ref spaceTransform.LinearTransform, out expansion);
Toolbox.ExpandBoundingBox(ref boundingBox, ref expansion);
}
public virtual ExportStatus Export(FScene scene, string filename)
{
int[] vertexMap = new int[2048]; // temp
List <WriteMesh> vMeshes = new List <WriteMesh>();
if (WriteFaceGroups)
{
throw new Exception("SceneMeshExporter.Export: writing face groups has not yet been implemented!");
}
// extract all the mesh data we want to export
foreach (SceneObject so in scene.SceneObjects)
{
if (so.IsTemporary || so.IsSurface == false || SceneUtil.IsVisible(so) == false)
{
continue;
}
if (SOFilterF != null && SOFilterF(so) == false)
{
continue;
}
// if this SO has an internal mesh we can just copy, use it
if (so is DMeshSO)
{
DMeshSO meshSO = so as DMeshSO;
// todo: flags
// make a copy of mesh
DMesh3 m = GetMeshForDMeshSO(meshSO);
// transform to scene coords and swap left/right
foreach (int vid in m.VertexIndices())
{
Vector3f v = (Vector3f)m.GetVertex(vid);
v = SceneTransforms.ObjectToSceneP(meshSO, v);
v = MeshTransforms.FlipLeftRightCoordSystems(v);
m.SetVertex(vid, v);
}
m.ReverseOrientation();
vMeshes.Add(new WriteMesh(m, so.Name));
}
// Look for lower-level fGameObject items to export. By default
// this is anything with a MeshFilter, override CollectGOChildren
// or use GOFilterF to add restrictions
List <fGameObject> vExports = CollectGOChildren(so);
if (vExports.Count > 0)
{
SimpleMesh m = new SimpleMesh();
m.Initialize(WriteNormals, WriteVertexColors, WriteUVs, WriteFaceGroups);
int groupCounter = 1;
foreach (fGameObject childgo in vExports)
{
if (GOFilterF != null && GOFilterF(so, childgo) == false)
{
continue;
}
if (AppendGOMesh(childgo, m, vertexMap, scene, groupCounter))
{
groupCounter++;
}
}
vMeshes.Add(new WriteMesh(m, so.Name));
}
}
// ok, we are independent of Scene now and can write in bg thread
if (WriteInBackgroundThreads)
{
ExportStatus status = new ExportStatus()
{
Exporter = this, IsComputing = true
};
WriteOptions useOptions = Options;
useOptions.ProgressFunc = (cur, max) => {
status.Progress = cur;
status.MaxProgress = max;
};
BackgroundWriteThread t = new BackgroundWriteThread()
{
Meshes = vMeshes, options = useOptions, Filename = filename,
CompletionF = (result) => {
LastWriteStatus = result.code;
LastErrorMessage = result.message;
status.LastErrorMessage = result.message;
status.Ok = (result.code == IOCode.Ok);
status.IsComputing = false;
if (BackgroundWriteCompleteF != null)
{
BackgroundWriteCompleteF(this, status);
}
}
};
t.Start();
return(status);
}
else
{
IOWriteResult result = StandardMeshWriter.WriteFile(filename, vMeshes, Options);
LastWriteStatus = result.code;
LastErrorMessage = result.message;
return(new ExportStatus()
{
Exporter = this, IsComputing = false,
Ok = (result.code == IOCode.Ok),
LastErrorMessage = result.message
});
}
}
/// <summary>
/// Constructs a new constraint which restricts two degrees of linear freedom and two degrees of angular freedom between two entities.
/// </summary>
/// <param name="connectionA">First entity of the constraint pair.</param>
/// <param name="connectionB">Second entity of the constraint pair.</param>
/// <param name="lineAnchor">Location of the anchor for the line to be attached to connectionA in world space.</param>
/// <param name="lineDirection">Axis in world space to be attached to connectionA along which connectionB can move and rotate.</param>
/// <param name="pointAnchor">Location of the anchor for the point to be attached to connectionB in world space.</param>
public LineSliderJoint(Entity connectionA, Entity connectionB, Vector3f lineAnchor, Vector3f lineDirection, Vector3f pointAnchor)
{
if (connectionA == null)
{
connectionA = TwoEntityConstraint.WorldEntity;
}
if (connectionB == null)
{
connectionB = TwoEntityConstraint.WorldEntity;
}
PointOnLineJoint = new PointOnLineJoint(connectionA, connectionB, lineAnchor, lineDirection, pointAnchor);
AngularJoint = new RevoluteAngularJoint(connectionA, connectionB, lineDirection);
Limit = new LinearAxisLimit(connectionA, connectionB, lineAnchor, pointAnchor, lineDirection, 0, 0);
Motor = new LinearAxisMotor(connectionA, connectionB, lineAnchor, pointAnchor, lineDirection);
Limit.IsActive = false;
Motor.IsActive = false;
Add(PointOnLineJoint);
Add(AngularJoint);
Add(Limit);
Add(Motor);
}
private ARImageNode CreateImageNode(ImageInfo imageInfo, Quaternion orientation, Vector3f scale, Vector3f position)
{
// ノードを作成
var texture = CreateTexture2D(imageInfo);
var imageNode = new ARImageNode(texture);
// 回転およびスケーリング
imageNode.Orientation = orientation;
imageNode.Scale = scale;
imageNode.Position = position;
return(imageNode);
}
public static Vector3f Copy(this Vector3f s)
{
return(new Vector3f(s.x, s.y, s.z));
}
public Bitmap AsImage(Model Parent, float scaleX = 1, float scaleY = 1, float scaleZ = 1, int rx = 0, int ry = 0, int rz = 0, bool wireframe = false, uint defaultcolour = 0xFFFFFFFF)
{
buffer = new Bitmap(512, 512);
int x = 256, y = 256;
rx &= 0xFF;
Matrix rotateX = new Matrix(
1, 0, 0,
0, (float)MyCos[rx], (float)MySin[rx],
0, (float)-MySin[rx], (float)MyCos[rx]);
ry &= 0xFF;
Matrix rotateY = new Matrix(
(float)MyCos[ry], 0, (float)-MySin[ry],
0, 1, 0,
(float)MySin[ry], 0, (float)MyCos[ry]);
rz &= 0xFF;
Matrix rotateZ = new Matrix(
(float)MyCos[rz], (float)-MySin[rz], 0,
(float)MySin[rz], (float)MyCos[rz], 0,
0, 0, 1);
Matrix transform = rotateX.Multiply(rotateY).Multiply(rotateZ);
int size = 512 * 512;
double[] zBuffer = new double[size];
for (int q = 0; q < size; q++)
{
zBuffer[q] = -9999999999.9f;
}
int wHalf = 512 / 2;
int hHalf = 512 / 2;
int FaceID = 0;
for (int i = 0; i < Parent.Faces.Count; i += Parent.FaceVerticiesCount, FaceID++)
{
int[] face = new int[Parent.FaceVerticiesCount];
for (int f = 0; f < Parent.FaceVerticiesCount; f++)
{
face[f] = Parent.Faces[i + f];
}
uint colour = defaultcolour;
if (Parent.HasColours)
{
colour = (uint)((255 << 24) + (Parent.Colours[Parent.Faces[i]].r << 16) + (Parent.Colours[Parent.Faces[i]].g << 8) + Parent.Colours[Parent.Faces[i]].b);
}
Vector3f xv = new Vector3f();
Vector3f yv = new Vector3f();
Vector3f zv = new Vector3f();
if (Parent.FaceVerticiesCount == 4 && !wireframe)
{
xv = new Vector3f(Vertices[face[0]].x, Vertices[face[0]].y, Vertices[face[0]].z);
yv = new Vector3f(Vertices[face[2]].x, Vertices[face[2]].y, Vertices[face[2]].z);
zv = new Vector3f(Vertices[face[3]].x, Vertices[face[3]].y, Vertices[face[3]].z);
Vector3f q_v1 = transform.Transform(xv).Multiply(scaleX, scaleY, scaleZ);
Vector3f q_v2 = transform.Transform(yv).Multiply(scaleX, scaleY, scaleZ);
Vector3f q_v3 = transform.Transform(zv).Multiply(scaleX, scaleY, scaleZ);
// Offset model
q_v1.x += x;
q_v1.y += y;
q_v2.x += x;
q_v2.y += y;
q_v3.x += x;
q_v3.y += y;
Vector3f q_n1 = transform.Transform(Vertices[face[0]].normal.Normalize());
Vector3f q_n2 = transform.Transform(Vertices[face[2]].normal.Normalize());
Vector3f q_n3 = transform.Transform(Vertices[face[3]].normal.Normalize());
Vector3f q_varying_intensity = new Vector3f();
Vector3f q_lightdir = new Vector3f(0.0f, -1.0f, 0.0f);
q_varying_intensity.x = Math.Max(0.0f, q_lightdir.DotProduct(q_n1));
q_varying_intensity.y = Math.Max(0.0f, q_lightdir.DotProduct(q_n2));
q_varying_intensity.z = Math.Max(0.0f, q_lightdir.DotProduct(q_n3));
double q_intensity = q_varying_intensity.Distance();
int q_minX = (int)Math.Max(0.0, Math.Ceiling(Math.Min(q_v1.x, Math.Min(q_v2.x, q_v3.x))));
int q_maxX = (int)Math.Min(wHalf * 2 - 1.0, Math.Floor(Math.Max(q_v1.x, Math.Max(q_v2.x, q_v3.x))));
int q_minY = (int)Math.Max(0.0, Math.Ceiling(Math.Min(q_v1.y, Math.Min(q_v2.y, q_v3.y))));
int q_maxY = (int)Math.Min(hHalf * 2 - 1.0, Math.Floor(Math.Max(q_v1.y, Math.Max(q_v2.y, q_v3.y))));
double triangleArea = (q_v1.y - q_v3.y) * (q_v2.x - q_v3.x) + (q_v2.y - q_v3.y) * (q_v3.x - q_v1.x);
for (int q_y = q_minY; q_y <= q_maxY; q_y++)
{
for (int q_x = q_minX; q_x <= q_maxX; q_x++)
{
double b1 = ((q_y - q_v3.y) * (q_v2.x - q_v3.x) + (q_v2.y - q_v3.y) * (q_v3.x - q_x)) / triangleArea;
double b2 = ((q_y - q_v1.y) * (q_v3.x - q_v1.x) + (q_v3.y - q_v1.y) * (q_v1.x - q_x)) / triangleArea;
double b3 = ((q_y - q_v2.y) * (q_v1.x - q_v2.x) + (q_v1.y - q_v2.y) * (q_v2.x - q_x)) / triangleArea;
if (b1 >= 0 && b1 <= 1 && b2 >= 0 && b2 <= 1 && b3 >= 0 && b3 <= 1)
{
double depth = b1 * q_v1.z + b2 * q_v2.z + b3 * q_v3.z;
q_intensity = (double)q_varying_intensity.DotProduct((float)b1, (float)b2, (float)b3);
int zIndex = q_y * wHalf * 2 + q_x;
if (zBuffer[zIndex] < depth)
{
if (q_intensity > 0.5)
{
System.Drawing.Color c = System.Drawing.Color.FromArgb(0xFF, System.Drawing.Color.FromArgb((int)ColourBlend(colour, 0xFFFFFF, q_intensity * 2.0 - 1.0)));
buffer.SetPixel(q_x, q_y, c);
}
else
{
System.Drawing.Color c = System.Drawing.Color.FromArgb(0xFF, System.Drawing.Color.FromArgb((int)ColourBlend(colour, 0x000000, (0.5 - q_intensity))));
buffer.SetPixel(q_x, q_y, c);
}
zBuffer[zIndex] = depth;
}
}
}
}
}
xv = new Vector3f(Vertices[face[0]].x, Vertices[face[0]].y, Vertices[face[0]].z);
yv = new Vector3f(Vertices[face[1]].x, Vertices[face[1]].y, Vertices[face[1]].z);
zv = new Vector3f(Vertices[face[2]].x, Vertices[face[2]].y, Vertices[face[2]].z);
Vector3f v1 = transform.Transform(xv).Multiply(scaleX, scaleY, scaleZ);
Vector3f v2 = transform.Transform(yv).Multiply(scaleX, scaleY, scaleZ);
Vector3f v3 = transform.Transform(zv).Multiply(scaleX, scaleY, scaleZ);
// Offset model
v1.x += x;
v1.y += y;
v2.x += x;
v2.y += y;
v3.x += x;
v3.y += y;
Vector3f n1 = transform.Transform(Vertices[face[0]].normal.Normalize());
Vector3f n2 = transform.Transform(Vertices[face[1]].normal.Normalize());
Vector3f n3 = transform.Transform(Vertices[face[1]].normal.Normalize());
Vector3f varying_intensity = new Vector3f();
Vector3f lightdir = new Vector3f(0.0f, -1.0f, 0.0f);
varying_intensity.x = Math.Max(0.0f, lightdir.DotProduct(n1));
varying_intensity.y = Math.Max(0.0f, lightdir.DotProduct(n2));
varying_intensity.z = Math.Max(0.0f, lightdir.DotProduct(n3));
double intensity;
int minX = (int)Math.Max(0.0, Math.Ceiling(Math.Min(v1.x, Math.Min(v2.x, v3.x))));
int maxX = (int)Math.Min(wHalf * 2 - 1.0, Math.Floor(Math.Max(v1.x, Math.Max(v2.x, v3.x))));
int minY = (int)Math.Max(0.0, Math.Ceiling(Math.Min(v1.y, Math.Min(v2.y, v3.y))));
int maxY = (int)Math.Min(hHalf * 2 - 1.0, Math.Floor(Math.Max(v1.y, Math.Max(v2.y, v3.y))));
if (wireframe)
{
intensity = Math.Min(1.0, Math.Max(0.0, varying_intensity.Distance()));
if (intensity > 0.5)
{
DrawLine((int)v1.x, (int)v1.y, (int)v2.x, (int)v2.y, ColourBlend(colour, 0xFFFFFF, intensity * 2.0 - 1.0));
DrawLine((int)v3.x, (int)v3.y, (int)v2.x, (int)v2.y, ColourBlend(colour, 0xFFFFFF, intensity * 2.0 - 1.0));
}
else
{
DrawLine((int)v1.x, (int)v1.y, (int)v2.x, (int)v2.y, ColourBlend(colour, 0x000000, (0.5 - intensity)));
DrawLine((int)v3.x, (int)v3.y, (int)v2.x, (int)v2.y, ColourBlend(colour, 0x000000, (0.5 - intensity)));
}
}
else
{
double triangleArea = (v1.y - v3.y) * (v2.x - v3.x) + (v2.y - v3.y) * (v3.x - v1.x);
for (int t_y = minY; t_y <= maxY; t_y++)
{
for (int t_x = minX; t_x <= maxX; t_x++)
{
double b1 = ((t_y - v3.y) * (v2.x - v3.x) + (v2.y - v3.y) * (v3.x - t_x)) / triangleArea;
double b2 = ((t_y - v1.y) * (v3.x - v1.x) + (v3.y - v1.y) * (v1.x - t_x)) / triangleArea;
double b3 = ((t_y - v2.y) * (v1.x - v2.x) + (v1.y - v2.y) * (v2.x - t_x)) / triangleArea;
if (b1 >= 0 && b1 <= 1 && b2 >= 0 && b2 <= 1 && b3 >= 0 && b3 <= 1)
{
double depth = b1 * v1.z + b2 * v2.z + b3 * v3.z;
// b1, b2, b3 make up "bar"; a Vector3
// fragment
intensity = varying_intensity.DotProduct((float)b1, (float)b2, (float)b3);
int zIndex = t_y * wHalf * 2 + t_x;
if (zBuffer[zIndex] < depth)
{
if (intensity > 0.5)
{
System.Drawing.Color c = System.Drawing.Color.FromArgb(0xFF, System.Drawing.Color.FromArgb((int)ColourBlend(colour, 0xFFFFFF, intensity * 2.0 - 1.0)));
buffer.SetPixel(t_x, t_y, c);
}
else
{
System.Drawing.Color c = System.Drawing.Color.FromArgb(0xFF, System.Drawing.Color.FromArgb((int)ColourBlend(colour, 0x000000, (0.5 - intensity))));
buffer.SetPixel(t_x, t_y, c);
}
zBuffer[zIndex] = depth;
}
}
}
}
}
}
return(buffer);
}
override public void SetLocalScale(Vector3f scale)
{
target.SetLocalScale(scale);
}
abstract public void SetLocalScale(Vector3f scale);
public override void manipulate(Particle particle, Vector3f deltaVelocity, Color4f deltaColor, ref float deltaLife)
{
deltaVelocity.set(particle.velocity);
deltaVelocity.stretch(strength);
deltaVelocity.invert();
}
/// <summary>
/// SV_movestep
/// Called by monster program code.
/// The move will be adjusted for slopes and stairs, but if the move isn't
/// possible, no move is done, false is returned, and
/// pr_global_struct.trace_normal is set to the normal of the blocking wall
/// </summary>
public Boolean MoveStep(MemoryEdict ent, ref Vector3f move, Boolean relink)
{
Trace_t trace;
// try the move
var oldorg = ent.v.origin;
Vector3f neworg;
MathLib.VectorAdd(ref ent.v.origin, ref move, out neworg);
// flying monsters don't step up
if ((( Int32 )ent.v.flags & (EdictFlags.FL_SWIM | EdictFlags.FL_FLY)) != 0)
{
// try one move with vertical motion, then one without
for (var i = 0; i < 2; i++)
{
MathLib.VectorAdd(ref ent.v.origin, ref move, out neworg);
var enemy = ProgToEdict(ent.v.enemy);
if (i == 0 && enemy != sv.edicts[0])
{
var dz = ent.v.origin.z - enemy.v.origin.z;
if (dz > 40)
{
neworg.z -= 8;
}
if (dz < 30)
{
neworg.z += 8;
}
}
trace = Move(ref ent.v.origin, ref ent.v.mins, ref ent.v.maxs, ref neworg, 0, ent);
if (trace.fraction == 1)
{
if ((( Int32 )ent.v.flags & EdictFlags.FL_SWIM) != 0 &&
PointContents(ref trace.endpos) == ( Int32 )Q1Contents.Empty)
{
return(false); // swim monster left water
}
MathLib.Copy(ref trace.endpos, out ent.v.origin);
if (relink)
{
LinkEdict(ent, true);
}
return(true);
}
if (enemy == sv.edicts[0])
{
break;
}
}
return(false);
}
// push down from a step height above the wished position
neworg.z += STEPSIZE;
var end = neworg;
end.z -= STEPSIZE * 2;
trace = Move(ref neworg, ref ent.v.mins, ref ent.v.maxs, ref end, 0, ent);
if (trace.allsolid)
{
return(false);
}
if (trace.startsolid)
{
neworg.z -= STEPSIZE;
trace = Move(ref neworg, ref ent.v.mins, ref ent.v.maxs, ref end, 0, ent);
if (trace.allsolid || trace.startsolid)
{
return(false);
}
}
if (trace.fraction == 1)
{
// if monster had the ground pulled out, go ahead and fall
if ((( Int32 )ent.v.flags & EdictFlags.FL_PARTIALGROUND) != 0)
{
MathLib.VectorAdd(ref ent.v.origin, ref move, out ent.v.origin);
if (relink)
{
LinkEdict(ent, true);
}
ent.v.flags = ( Int32 )ent.v.flags & ~EdictFlags.FL_ONGROUND;
return(true);
}
return(false); // walked off an edge
}
// check point traces down for dangling corners
MathLib.Copy(ref trace.endpos, out ent.v.origin);
if (!CheckBottom(ent))
{
if ((( Int32 )ent.v.flags & EdictFlags.FL_PARTIALGROUND) != 0)
{
// entity had floor mostly pulled out from underneath it
// and is trying to correct
if (relink)
{
LinkEdict(ent, true);
}
return(true);
}
ent.v.origin = oldorg;
return(false);
}
if ((( Int32 )ent.v.flags & EdictFlags.FL_PARTIALGROUND) != 0)
{
ent.v.flags = ( Int32 )ent.v.flags & ~EdictFlags.FL_PARTIALGROUND;
}
ent.v.groundentity = EdictToProg(trace.ent);
// the move is ok
if (relink)
{
LinkEdict(ent, true);
}
return(true);
}
