protected void PrepareVerticesLight(ref VertexC1P3T2A4[] vertices, IDrawDevice device, ColorRgba mainClr, Rect uvRect, DrawTechnique tech)
{
bool perPixel = tech is LightingTechnique;
Vector3 pos = this.GameObj.Transform.Pos;
Vector3 posTemp = pos;
float scaleTemp = 1.0f;
device.PreprocessCoords(ref posTemp, ref scaleTemp);
Vector2 xDot, yDot;
float rotation = this.GameObj.Transform.Angle;
MathF.GetTransformDotVec(rotation, out xDot, out yDot);
Rect rectTemp = this.rect.Transform(this.GameObj.Transform.Scale, this.GameObj.Transform.Scale);
Vector2 edge1 = rectTemp.TopLeft;
Vector2 edge2 = rectTemp.BottomLeft;
Vector2 edge3 = rectTemp.BottomRight;
Vector2 edge4 = rectTemp.TopRight;
MathF.TransformDotVec(ref edge1, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge2, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge3, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge4, ref xDot, ref yDot);
// Using Per-Vertex Lighting? Calculate vertex light values
Vector4[] vertexLight = null;
if (!perPixel)
{
vertexLight = new Vector4[4];
Light.GetLightAtWorldPos(pos + new Vector3(edge1), out vertexLight[0], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge2), out vertexLight[1], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge3), out vertexLight[2], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge4), out vertexLight[3], this.vertexTranslucency);
}
Vector2.Multiply(ref edge1, scaleTemp, out edge1);
Vector2.Multiply(ref edge2, scaleTemp, out edge2);
Vector2.Multiply(ref edge3, scaleTemp, out edge3);
Vector2.Multiply(ref edge4, scaleTemp, out edge4);
// Using Per-Pixel Lighting? Pass objRotation Matrix via vertex attribute.
Vector4 objRotMat = Vector4.Zero;
if (perPixel)
{
objRotMat = new Vector4((float)Math.Cos(-rotation), -(float)Math.Sin(-rotation), (float)Math.Sin(-rotation), (float)Math.Cos(-rotation));
}
if (vertices == null || vertices.Length != 4)
{
vertices = new VertexC1P3T2A4[4];
}
// Directly pass World Position with each vertex, see note in Light.cs
vertices[0].pos.X = posTemp.X + edge1.X;
vertices[0].pos.Y = posTemp.Y + edge1.Y;
vertices[0].pos.Z = posTemp.Z + this.VertexZOffset;
vertices[0].texCoord.X = uvRect.X;
vertices[0].texCoord.Y = uvRect.Y;
vertices[0].clr = mainClr;
vertices[0].attrib = perPixel ? objRotMat : vertexLight[0];
vertices[1].pos.X = posTemp.X + edge2.X;
vertices[1].pos.Y = posTemp.Y + edge2.Y;
vertices[1].pos.Z = posTemp.Z + this.VertexZOffset;
vertices[1].texCoord.X = uvRect.X;
vertices[1].texCoord.Y = uvRect.MaxY;
vertices[1].clr = mainClr;
vertices[1].attrib = perPixel ? objRotMat : vertexLight[1];
vertices[2].pos.X = posTemp.X + edge3.X;
vertices[2].pos.Y = posTemp.Y + edge3.Y;
vertices[2].pos.Z = posTemp.Z + this.VertexZOffset;
vertices[2].texCoord.X = uvRect.MaxX;
vertices[2].texCoord.Y = uvRect.MaxY;
vertices[2].clr = mainClr;
vertices[2].attrib = perPixel ? objRotMat : vertexLight[2];
vertices[3].pos.X = posTemp.X + edge4.X;
vertices[3].pos.Y = posTemp.Y + edge4.Y;
vertices[3].pos.Z = posTemp.Z + this.VertexZOffset;
vertices[3].texCoord.X = uvRect.MaxX;
vertices[3].texCoord.Y = uvRect.Y;
vertices[3].clr = mainClr;
vertices[3].attrib = perPixel ? objRotMat : vertexLight[3];
}
protected void PrepareVerticesLight(ref VertexDynamicLighting[] vertices, IDrawDevice device, ColorRgba mainClr, Rect uvRect, DrawTechnique tech)
{
bool perPixel = tech is LightingTechnique;
Vector3 pos = this.GameObj.Transform.Pos;
Vector2 xDot, yDot;
float rotation = this.GameObj.Transform.Angle;
MathF.GetTransformDotVec(rotation, out xDot, out yDot);
Rect rectTemp = this.rect.Transformed(this.GameObj.Transform.Scale, this.GameObj.Transform.Scale);
Vector2 edge1 = rectTemp.TopLeft;
Vector2 edge2 = rectTemp.BottomLeft;
Vector2 edge3 = rectTemp.BottomRight;
Vector2 edge4 = rectTemp.TopRight;
MathF.TransformDotVec(ref edge1, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge2, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge3, ref xDot, ref yDot);
MathF.TransformDotVec(ref edge4, ref xDot, ref yDot);
// Using Per-Vertex Lighting? Calculate vertex light values
Vector4[] vertexLight = null;
if (!perPixel)
{
vertexLight = new Vector4[4];
Light.GetLightAtWorldPos(pos + new Vector3(edge1), out vertexLight[0], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge2), out vertexLight[1], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge3), out vertexLight[2], this.vertexTranslucency);
Light.GetLightAtWorldPos(pos + new Vector3(edge4), out vertexLight[3], this.vertexTranslucency);
}
// Using Per-Pixel Lighting? Pass objRotation Matrix via vertex attribute.
Vector4 objRotMat = Vector4.Zero;
if (perPixel)
{
objRotMat = new Vector4((float)Math.Cos(-rotation), -(float)Math.Sin(-rotation), (float)Math.Sin(-rotation), (float)Math.Cos(-rotation));
}
// Calculate UV coordinates
float left = uvRect.X;
float right = uvRect.RightX;
float top = uvRect.Y;
float bottom = uvRect.BottomY;
if ((this.flipMode & FlipMode.Horizontal) != FlipMode.None)
{
MathF.Swap(ref left, ref right);
}
if ((this.flipMode & FlipMode.Vertical) != FlipMode.None)
{
MathF.Swap(ref top, ref bottom);
}
if (vertices == null || vertices.Length != 4)
{
vertices = new VertexDynamicLighting[4];
}
// Directly pass World Position with each vertex, see note in Light.cs
vertices[0].Pos.X = pos.X + edge1.X;
vertices[0].Pos.Y = pos.Y + edge1.Y;
vertices[0].Pos.Z = pos.Z;
vertices[0].DepthOffset = this.offset;
vertices[0].TexCoord.X = left;
vertices[0].TexCoord.Y = top;
vertices[0].Color = mainClr;
vertices[0].LightingParam = perPixel ? objRotMat : vertexLight[0];
vertices[1].Pos.X = pos.X + edge2.X;
vertices[1].Pos.Y = pos.Y + edge2.Y;
vertices[1].Pos.Z = pos.Z;
vertices[1].DepthOffset = this.offset;
vertices[1].TexCoord.X = left;
vertices[1].TexCoord.Y = bottom;
vertices[1].Color = mainClr;
vertices[1].LightingParam = perPixel ? objRotMat : vertexLight[1];
vertices[2].Pos.X = pos.X + edge3.X;
vertices[2].Pos.Y = pos.Y + edge3.Y;
vertices[2].Pos.Z = pos.Z;
vertices[2].DepthOffset = this.offset;
vertices[2].TexCoord.X = right;
vertices[2].TexCoord.Y = bottom;
vertices[2].Color = mainClr;
vertices[2].LightingParam = perPixel ? objRotMat : vertexLight[2];
vertices[3].Pos.X = pos.X + edge4.X;
vertices[3].Pos.Y = pos.Y + edge4.Y;
vertices[3].Pos.Z = pos.Z;
vertices[3].DepthOffset = this.offset;
vertices[3].TexCoord.X = right;
vertices[3].TexCoord.Y = top;
vertices[3].Color = mainClr;
vertices[3].LightingParam = perPixel ? objRotMat : vertexLight[3];
if (this.pixelGrid)
{
vertices[0].Pos.X = MathF.Round(vertices[0].Pos.X);
vertices[1].Pos.X = MathF.Round(vertices[1].Pos.X);
vertices[2].Pos.X = MathF.Round(vertices[2].Pos.X);
vertices[3].Pos.X = MathF.Round(vertices[3].Pos.X);
if (MathF.RoundToInt(device.TargetSize.X) != (MathF.RoundToInt(device.TargetSize.X) / 2) * 2)
{
vertices[0].Pos.X += 0.5f;
vertices[1].Pos.X += 0.5f;
vertices[2].Pos.X += 0.5f;
vertices[3].Pos.X += 0.5f;
}
vertices[0].Pos.Y = MathF.Round(vertices[0].Pos.Y);
vertices[1].Pos.Y = MathF.Round(vertices[1].Pos.Y);
vertices[2].Pos.Y = MathF.Round(vertices[2].Pos.Y);
vertices[3].Pos.Y = MathF.Round(vertices[3].Pos.Y);
if (MathF.RoundToInt(device.TargetSize.Y) != (MathF.RoundToInt(device.TargetSize.Y) / 2) * 2)
{
vertices[0].Pos.Y += 0.5f;
vertices[1].Pos.Y += 0.5f;
vertices[2].Pos.Y += 0.5f;
vertices[3].Pos.Y += 0.5f;
}
}
}