internal static IEnumerable <int> GetLinkedBoneIndexes(DistortionMesh mesh)
{
foreach (var point in mesh.Nodes.OfType <DistortionMeshPoint>())
{
if (point.SkinningWeights?.IsEmpty() ?? true)
{
continue;
}
if (point.SkinningWeights.Bone0.Index != 0)
{
yield return(point.SkinningWeights.Bone0.Index);
}
if (point.SkinningWeights.Bone1.Index != 0)
{
yield return(point.SkinningWeights.Bone1.Index);
}
if (point.SkinningWeights.Bone2.Index != 0)
{
yield return(point.SkinningWeights.Bone2.Index);
}
if (point.SkinningWeights.Bone3.Index != 0)
{
yield return(point.SkinningWeights.Bone3.Index);
}
}
}
void WriteDistortionMeshProperties(DistortionMesh node)
{
WriteWidgetProperties(node);
WriteProperty("TexturePath", node.Texture, null);
WriteProperty("NumRows", node.NumRows, 2);
WriteProperty("NumCols", node.NumCols, 2);
}
void RestorePointsIfNeeded(DistortionMesh mesh)
{
if (ValidateMeshPoints(mesh))
{
return;
}
var rootFolder = mesh.RootFolder();
foreach (var item in rootFolder.Items.ToList())
{
UnlinkFolderItem.Perform(mesh, item);
}
for (int i = 0; i <= mesh.NumRows; i++)
{
for (int j = 0; j <= mesh.NumCols; j++)
{
var pos = new Vector2((float)j / mesh.NumCols, (float)i / mesh.NumRows);
var point = new DistortionMeshPoint {
Id = $"{i};{j}",
Color = Color4.White,
UV = pos,
Position = pos
};
InsertFolderItem.Perform(mesh, new FolderItemLocation(rootFolder, rootFolder.Items.Count), point);
}
}
}
private static ContentSizeComponent ProcessDistortionMesh(DistortionMesh distortionMesh)
{
if (distortionMesh.Nodes.Count == 0)
{
return(ProcessEmptyNode(distortionMesh));
}
var aabb = distortionMesh.GetLocalAABB();
var selfSize = distortionMesh.Components.GetOrAdd <ContentSizeComponent>();
selfSize.Size = new ContentRectangle(aabb, Vector2.One / distortionMesh.Size);
return(selfSize);
}
bool ValidateMeshPoints(DistortionMesh mesh)
{
if ((mesh.NumRows + 1) * (mesh.NumCols + 1) != mesh.Nodes.Count)
{
return(false);
}
int t = 0;
for (int i = 0; i <= mesh.NumRows; i++)
{
for (int j = 0; j <= mesh.NumCols; j++)
{
if (t >= mesh.Nodes.Count || mesh.Nodes[t].Id != $"{i};{j}")
{
return(false);
}
t++;
}
}
return(true);
}
public void onProjectionChanged(HeadMountedDisplay hmd, EyeParams leftEye, EyeParams rightEye, float zNear, float zFar)
{
mHmd = new HeadMountedDisplay(hmd);
mLeftEyeFov = new FieldOfView(leftEye.getFov());
mRightEyeFov = new FieldOfView(rightEye.getFov());
ScreenParams screen = mHmd.getScreen();
CardboardDeviceParams cdp = mHmd.getCardboard();
if (mProgramHolder == null)
{
mProgramHolder = createProgramHolder();
}
EyeViewport leftEyeViewport = initViewportForEye(leftEye, 0.0F);
EyeViewport rightEyeViewport = initViewportForEye(rightEye, leftEyeViewport.width);
leftEye.getFov().toPerspectiveMatrix(zNear, zFar, leftEye.getTransform().GetPerspective(), 0);
rightEye.getFov().toPerspectiveMatrix(zNear, zFar, rightEye.getTransform().GetPerspective(), 0);
float textureWidthM = leftEyeViewport.width + rightEyeViewport.width;
float textureHeightM = Math.Max(leftEyeViewport.height, rightEyeViewport.height);
float xPxPerM = screen.getWidth() / screen.getWidthMeters();
float yPxPerM = screen.getHeight() / screen.getHeightMeters();
int textureWidthPx = Math.Round(textureWidthM * xPxPerM);
int textureHeightPx = Math.Round(textureHeightM * yPxPerM);
float xEyeOffsetMScreen = screen.getWidthMeters() / 2.0F - cdp.getInterpupillaryDistance() / 2.0F;
float yEyeOffsetMScreen = cdp.getVerticalDistanceToLensCenter() - screen.getBorderSizeMeters();
mLeftEyeDistortionMesh = createDistortionMesh(leftEye, leftEyeViewport, textureWidthM, textureHeightM, xEyeOffsetMScreen, yEyeOffsetMScreen);
xEyeOffsetMScreen = screen.getWidthMeters() - xEyeOffsetMScreen;
mRightEyeDistortionMesh = createDistortionMesh(rightEye, rightEyeViewport, textureWidthM, textureHeightM, xEyeOffsetMScreen, yEyeOffsetMScreen);
setupRenderTextureAndRenderbuffer(textureWidthPx, textureHeightPx);
}
void ParseDistortionMeshProperty(Node node, string name)
{
DistortionMesh mesh = (DistortionMesh)node;
switch (name)
{
case "NumRows":
mesh.NumRows = lexer.ParseInt();
break;
case "NumCols":
mesh.NumCols = lexer.ParseInt();
break;
case "TexturePath":
mesh.Texture = new SerializableTexture(lexer.ParsePath());
break;
default:
ParseGraphicProperty(mesh, name);
break;
}
}
private void renderDistortionMesh(DistortionMesh mesh)
{
GLES20.GlBindBuffer(34962, mesh.mArrayBufferId);
/*mesh.getClass(); mesh.getClass();*/ GLES20.GlVertexAttribPointer(mProgramHolder.aPosition, 3, 5126, false, 20, 0 * 4);
GLES20.GlEnableVertexAttribArray(mProgramHolder.aPosition);
/*mesh.getClass(); mesh.getClass();*/ GLES20.GlVertexAttribPointer(mProgramHolder.aVignette, 1, 5126, false, 20, 2 * 4);
GLES20.GlEnableVertexAttribArray(mProgramHolder.aVignette);
/*mesh.getClass(); mesh.getClass();*/ GLES20.GlVertexAttribPointer(mProgramHolder.aTextureCoord, 2, 5126, false, 20, 3 * 4);
GLES20.GlEnableVertexAttribArray(mProgramHolder.aTextureCoord);
GLES20.GlActiveTexture(33984);
GLES20.GlBindTexture(3553, mTextureId);
GLES20.GlUniform1i(mProgramHolder.uTextureSampler, 0);
GLES20.GlUniform1f(mProgramHolder.uTextureCoordScale, mResolutionScale);
GLES20.GlBindBuffer(34963, mesh.mElementBufferId);
GLES20.GlDrawElements(5, mesh.nIndices, 5125, 0);
}
public static Rectangle GetLocalAABB(this DistortionMesh mesh)
{
var parent = mesh.ParentWidget;
var existsAnimation = false;
var animationStart = int.MaxValue;
var animationEnd = 0;
foreach (var bone in parent.Nodes.OfType <Bone>())
{
foreach (var animator in bone.Animators)
{
existsAnimation = true;
animationStart = Math.Min(animationStart, animator.Keys.First().Frame);
animationEnd = Math.Max(animationEnd, animator.Duration);
}
}
if (!existsAnimation)
{
animationStart = animationEnd = parent.DefaultAnimation.Frame;
}
var existsPointAnimation = false;
var pointsAnimationStart = int.MaxValue;
var pointsAnimationEnd = 0;
foreach (var point in mesh.Nodes.OfType <DistortionMeshPoint>())
{
foreach (var animator in point.Animators)
{
existsPointAnimation = true;
pointsAnimationStart = Math.Min(pointsAnimationStart, animator.Keys.First().Frame);
pointsAnimationEnd = Math.Max(pointsAnimationEnd, animator.Duration);
}
}
if (!existsPointAnimation)
{
pointsAnimationStart = pointsAnimationEnd = mesh.DefaultAnimation.Frame;
}
var rectangle = new Rectangle(float.MaxValue, float.MaxValue, float.MinValue, float.MinValue);
var animationFrame = parent.DefaultAnimation.Frame;
var pointsAnimationFrame = mesh.DefaultAnimation.Frame;
for (var frame = animationStart; frame <= animationEnd; frame++)
{
parent.DefaultAnimation.Frame = frame;
var bones = parent.BoneArray;
var weightsMatrix = mesh.CalcLocalToParentTransform();
var weightsMatrixInversed = weightsMatrix.CalcInversed();
for (var pointsFrame = pointsAnimationStart; pointsFrame <= pointsAnimationEnd; pointsFrame++)
{
mesh.DefaultAnimation.Frame = frame;
for (var i = 0; i < mesh.Nodes.Count; i++)
{
var point = (DistortionMeshPoint)mesh.Nodes[i];
rectangle = ExpandMeshLocalAABB(rectangle, mesh.Size, point, bones, weightsMatrix, weightsMatrixInversed);
}
}
}
parent.DefaultAnimation.Frame = animationFrame;
mesh.DefaultAnimation.Frame = pointsAnimationFrame;
return(rectangle);
}
