/// <summary> Returns a model view matrix for rendering a carried block on the specified attachment point. </summary>
private float[] GetAttachmentPointMatrix(EntityShapeRenderer renderer, AttachmentPointAndPose attachPointAndPose)
{
var modelMat = Mat4f.CloneIt(renderer.ModelMat);
var animModelMat = attachPointAndPose.AnimModelMatrix;
Mat4f.Mul(modelMat, modelMat, animModelMat);
// Apply attachment point transform.
var attach = attachPointAndPose.AttachPoint;
Mat4f.Translate(modelMat, modelMat, (float)(attach.PosX / 16), (float)(attach.PosY / 16), (float)(attach.PosZ / 16));
Mat4f.RotateX(modelMat, modelMat, (float)attach.RotationX * GameMath.DEG2RAD);
Mat4f.RotateY(modelMat, modelMat, (float)attach.RotationY * GameMath.DEG2RAD);
Mat4f.RotateZ(modelMat, modelMat, (float)attach.RotationZ * GameMath.DEG2RAD);
return(modelMat);
}
/// <summary>
/// If an attachment point called "Center" exists, then this method
/// offsets the creatures collision box so that the Center attachment point is the center of the collision box.
/// </summary>
public void AdjustCollisionBoxToAnimation(float dtFac)
{
float[] hitboxOff = new float[4] {
0, 0, 0, 1
};
AttachmentPointAndPose apap = entity.AnimManager.Animator.GetAttachmentPointPose("Center");
if (apap == null)
{
return;
}
AttachmentPoint ap = apap.AttachPoint;
float rotX = entity.Properties.Client.Shape != null ? entity.Properties.Client.Shape.rotateX : 0;
float rotY = entity.Properties.Client.Shape != null ? entity.Properties.Client.Shape.rotateY : 0;
float rotZ = entity.Properties.Client.Shape != null ? entity.Properties.Client.Shape.rotateZ : 0;
float[] ModelMat = Mat4f.Create();
Mat4f.Identity(ModelMat);
Mat4f.Translate(ModelMat, ModelMat, 0, entity.CollisionBox.Y2 / 2, 0);
double[] quat = Quaterniond.Create();
Quaterniond.RotateX(quat, quat, entity.Pos.Pitch + rotX * GameMath.DEG2RAD);
Quaterniond.RotateY(quat, quat, entity.Pos.Yaw + (rotY + 90) * GameMath.DEG2RAD);
Quaterniond.RotateZ(quat, quat, entity.Pos.Roll + rotZ * GameMath.DEG2RAD);
float[] qf = new float[quat.Length];
for (int k = 0; k < quat.Length; k++)
{
qf[k] = (float)quat[k];
}
Mat4f.Mul(ModelMat, ModelMat, Mat4f.FromQuat(Mat4f.Create(), qf));
float scale = entity.Properties.Client.Size;
Mat4f.Translate(ModelMat, ModelMat, 0, -entity.CollisionBox.Y2 / 2, 0f);
Mat4f.Scale(ModelMat, ModelMat, new float[] { scale, scale, scale });
Mat4f.Translate(ModelMat, ModelMat, -0.5f, 0, -0.5f);
tmpModelMat
.Set(ModelMat)
.Mul(apap.AnimModelMatrix)
.Translate(ap.PosX / 16f, ap.PosY / 16f, ap.PosZ / 16f)
;
EntityPos epos = entity.SidedPos;
float[] endVec = Mat4f.MulWithVec4(tmpModelMat.Values, hitboxOff);
float motionX = endVec[0] - (entity.CollisionBox.X1 - entity.OriginCollisionBox.X1);
float motionZ = endVec[2] - (entity.CollisionBox.Z1 - entity.OriginCollisionBox.Z1);
if (Math.Abs(motionX) > 0.00001 || Math.Abs(motionZ) > 0.00001)
{
EntityPos posMoved = epos.Copy();
posMoved.Motion.X = motionX;
posMoved.Motion.Z = motionZ;
moveDelta.Set(posMoved.Motion.X, posMoved.Motion.Y, posMoved.Motion.Z);
collisionTester.ApplyTerrainCollision(entity, posMoved, dtFac, ref outposition);
double reflectX = outposition.X - epos.X - motionX;
double reflectZ = outposition.Z - epos.Z - motionZ;
epos.Motion.X = reflectX;
epos.Motion.Z = reflectZ;
entity.CollisionBox.Set(entity.OriginCollisionBox);
entity.CollisionBox.Translate(endVec[0], 0, endVec[2]);
}
//Console.WriteLine("{0}/{1}", reflectX, reflectZ);
}
private void RenderBackPack(EntityPlayer entity, EntityShapeRenderer rend, bool isShadowPass)
{
IRenderAPI rpi = api.Render;
ClientAnimator animator = entity.AnimManager.Animator as ClientAnimator;
AttachmentPointAndPose apap = null;
animator.AttachmentPointByCode.TryGetValue("Back", out apap);
if (apap == null || backPackMeshRef == null)
{
return;
}
for (int i = 0; i < 16; i++)
{
modelMat[i] = rend.ModelMat[i];
}
AttachmentPoint ap = apap.AttachPoint;
float[] animModelMat = apap.CachedPose.AnimModelMatrix;
float[] viewMatrix = new float[16];
for (int i = 0; i < 16; i++)
{
viewMatrix[i] = (float)api.Render.CameraMatrixOrigin[i];
}
Mat4f.Mul(modelMat, modelMat, animModelMat);
IStandardShaderProgram prog = null;
if (isShadowPass)
{
rpi.CurrentActiveShader.BindTexture2D("tex2d", backPackTextureId, 0);
}
else
{
prog = rpi.PreparedStandardShader((int)entity.Pos.X, (int)entity.Pos.Y, (int)entity.Pos.Z);
prog.Tex2D = backPackTextureId;
prog.AlphaTest = 0.01f;
}
Mat4f.Translate(modelMat, modelMat, backPackTransform.Origin.X, backPackTransform.Origin.Y, backPackTransform.Origin.Z);
Mat4f.Scale(modelMat, modelMat, backPackTransform.ScaleXYZ.X, backPackTransform.ScaleXYZ.Y, backPackTransform.ScaleXYZ.Z);
Mat4f.Translate(modelMat, modelMat, (float)ap.PosX / 16f + backPackTransform.Translation.X, (float)ap.PosY / 16f + backPackTransform.Translation.Y, (float)ap.PosZ / 16f + backPackTransform.Translation.Z);
Mat4f.RotateX(modelMat, modelMat, (float)(ap.RotationX + backPackTransform.Rotation.X) * GameMath.DEG2RAD);
Mat4f.RotateY(modelMat, modelMat, (float)(ap.RotationY + backPackTransform.Rotation.Y) * GameMath.DEG2RAD);
Mat4f.RotateZ(modelMat, modelMat, (float)(ap.RotationZ + backPackTransform.Rotation.Z) * GameMath.DEG2RAD);
Mat4f.Translate(modelMat, modelMat, -(backPackTransform.Origin.X), -(backPackTransform.Origin.Y), -(backPackTransform.Origin.Z));
if (isShadowPass)
{
Mat4f.Mul(modelMat, api.Render.CurrentShadowProjectionMatrix, modelMat);
api.Render.CurrentActiveShader.UniformMatrix("mvpMatrix", modelMat);
api.Render.CurrentActiveShader.Uniform("origin", rend.OriginPos);
}
else
{
prog.ModelMatrix = modelMat;
prog.ViewMatrix = viewMatrix;
}
api.Render.RenderMesh(backPackMeshRef);
if (!isShadowPass)
{
prog.Stop();
}
}
protected void RenderHeldItem(float dt, bool isShadowPass, bool right)
{
IRenderAPI rapi = capi.Render;
ItemSlot slot = right ? eagent?.RightHandItemSlot : eagent?.LeftHandItemSlot;
ItemStack stack = slot?.Itemstack;
AttachmentPointAndPose apap = entity.AnimManager.Animator.GetAttachmentPointPose(right ? "RightHand" : "LeftHand");
if (apap == null || stack == null)
{
return;
}
AttachmentPoint ap = apap.AttachPoint;
ItemRenderInfo renderInfo = rapi.GetItemStackRenderInfo(slot, right ? EnumItemRenderTarget.HandTp : EnumItemRenderTarget.HandTpOff);
IStandardShaderProgram prog = null;
if (renderInfo?.Transform == null)
{
return; // Happens with unknown items/blocks
}
ItemModelMat
.Set(ModelMat)
.Mul(apap.AnimModelMatrix)
.Translate(renderInfo.Transform.Origin.X, renderInfo.Transform.Origin.Y, renderInfo.Transform.Origin.Z)
.Scale(renderInfo.Transform.ScaleXYZ.X, renderInfo.Transform.ScaleXYZ.Y, renderInfo.Transform.ScaleXYZ.Z)
.Translate(ap.PosX / 16f + renderInfo.Transform.Translation.X, ap.PosY / 16f + renderInfo.Transform.Translation.Y, ap.PosZ / 16f + renderInfo.Transform.Translation.Z)
.RotateX((float)(ap.RotationX + renderInfo.Transform.Rotation.X) * GameMath.DEG2RAD)
.RotateY((float)(ap.RotationY + renderInfo.Transform.Rotation.Y) * GameMath.DEG2RAD)
.RotateZ((float)(ap.RotationZ + renderInfo.Transform.Rotation.Z) * GameMath.DEG2RAD)
.Translate(-(renderInfo.Transform.Origin.X), -(renderInfo.Transform.Origin.Y), -(renderInfo.Transform.Origin.Z))
;
if (isShadowPass)
{
rapi.CurrentActiveShader.BindTexture2D("tex2d", renderInfo.TextureId, 0);
float[] mvpMat = Mat4f.Mul(ItemModelMat.Values, capi.Render.CurrentModelviewMatrix, ItemModelMat.Values);
Mat4f.Mul(mvpMat, capi.Render.CurrentProjectionMatrix, mvpMat);
capi.Render.CurrentActiveShader.UniformMatrix("mvpMatrix", mvpMat);
capi.Render.CurrentActiveShader.Uniform("origin", new Vec3f());
}
else
{
prog = rapi.StandardShader;
prog.Use();
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
prog.NormalShaded = 1;
prog.Tex2D = renderInfo.TextureId;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.AlphaTest = renderInfo.AlphaTest;
prog.DamageEffect = renderInfo.DamageEffect;
prog.OverlayOpacity = renderInfo.OverlayOpacity;
if (renderInfo.OverlayTexture != null && renderInfo.OverlayOpacity > 0)
{
prog.Tex2dOverlay2D = renderInfo.OverlayTexture.TextureId;
prog.OverlayTextureSize = new Vec2f(renderInfo.OverlayTexture.Width, renderInfo.OverlayTexture.Height);
prog.BaseTextureSize = new Vec2f(renderInfo.TextureSize.Width, renderInfo.TextureSize.Height);
TextureAtlasPosition texPos = rapi.GetTextureAtlasPosition(stack);
prog.BaseUvOrigin = new Vec2f(texPos.x1, texPos.y1);
}
int temp = (int)stack.Collectible.GetTemperature(capi.World, stack);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
/*lightrgbs[0] += glowColor[0];
* lightrgbs[1] += glowColor[1];
* lightrgbs[2] += glowColor[2];*/
var gi = GameMath.Clamp((temp - 500) / 3, 0, 255);
prog.ExtraGlow = gi;
prog.RgbaAmbientIn = rapi.AmbientColor;
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], gi / 255f);
prog.RgbaFogIn = rapi.FogColor;
prog.FogMinIn = rapi.FogMin;
prog.FogDensityIn = rapi.FogDensity;
prog.NormalShaded = renderInfo.NormalShaded ? 1 : 0;
prog.ProjectionMatrix = rapi.CurrentProjectionMatrix;
prog.ViewMatrix = rapi.CameraMatrixOriginf;
prog.ModelMatrix = ItemModelMat.Values;
}
if (!renderInfo.CullFaces)
{
rapi.GlDisableCullFace();
}
rapi.RenderMesh(renderInfo.ModelRef);
if (!renderInfo.CullFaces)
{
rapi.GlEnableCullFace();
}
if (!isShadowPass)
{
prog.DamageEffect = 0;
}
if (!isShadowPass)
{
prog.Stop();
AdvancedParticleProperties[] ParticleProperties = stack.Collectible?.ParticleProperties;
if (stack.Collectible != null && !capi.IsGamePaused)
{
Vec4f pos = ItemModelMat.TransformVector(new Vec4f(stack.Collectible.TopMiddlePos.X, stack.Collectible.TopMiddlePos.Y, stack.Collectible.TopMiddlePos.Z, 1));
EntityPlayer entityPlayer = capi.World.Player.Entity;
accum += dt;
if (ParticleProperties != null && ParticleProperties.Length > 0 && accum > 0.025f)
{
accum = accum % 0.025f;
for (int i = 0; i < ParticleProperties.Length; i++)
{
AdvancedParticleProperties bps = ParticleProperties[i];
bps.basePos.X = pos.X + entity.Pos.X + -(entity.Pos.X - entityPlayer.CameraPos.X);
bps.basePos.Y = pos.Y + entity.Pos.Y + -(entity.Pos.Y - entityPlayer.CameraPos.Y);
bps.basePos.Z = pos.Z + entity.Pos.Z + -(entity.Pos.Z - entityPlayer.CameraPos.Z);
eagent.World.SpawnParticles(bps);
}
}
}
}
}
void RenderHeldItem(bool isShadowPass)
{
IRenderAPI rapi = capi.Render;
ItemStack stack = (entity as IEntityAgent).RightHandItemSlot?.Itemstack;
BlendEntityAnimator bea = curAnimator as BlendEntityAnimator;
AttachmentPointAndPose apap = null;
bea.AttachmentPointByCode.TryGetValue("RightHand", out apap);
if (apap == null || stack == null)
{
return;
}
AttachmentPoint ap = apap.AttachPoint;
ItemRenderInfo renderInfo = rapi.GetItemStackRenderInfo(stack, EnumItemRenderTarget.HandTp);
IStandardShaderProgram prog = null;
EntityPlayer entityPlayer = capi.World.Player.Entity;
ItemModelMat
.Set(ModelMat)
.Mul(apap.Pose.AnimModelMatrix)
.Translate(renderInfo.Transform.Origin.X, renderInfo.Transform.Origin.Y, renderInfo.Transform.Origin.Z)
.Scale(renderInfo.Transform.ScaleXYZ.X, renderInfo.Transform.ScaleXYZ.Y, renderInfo.Transform.ScaleXYZ.Z)
.Translate(ap.PosX / 16f + renderInfo.Transform.Translation.X, ap.PosY / 16f + renderInfo.Transform.Translation.Y, ap.PosZ / 16f + renderInfo.Transform.Translation.Z)
.RotateX((float)(ap.RotationX + renderInfo.Transform.Rotation.X) * GameMath.DEG2RAD)
.RotateY((float)(ap.RotationY + renderInfo.Transform.Rotation.Y) * GameMath.DEG2RAD)
.RotateZ((float)(ap.RotationZ + renderInfo.Transform.Rotation.Z) * GameMath.DEG2RAD)
.Translate(-(renderInfo.Transform.Origin.X), -(renderInfo.Transform.Origin.Y), -(renderInfo.Transform.Origin.Z))
;
if (isShadowPass)
{
rapi.CurrentActiveShader.BindTexture2D("tex2d", renderInfo.TextureId, 0);
float[] mvpMat = Mat4f.Mul(ItemModelMat.Values, capi.Render.CurrentModelviewMatrix, ItemModelMat.Values);
Mat4f.Mul(mvpMat, capi.Render.CurrentProjectionMatrix, mvpMat);
capi.Render.CurrentActiveShader.UniformMatrix("mvpMatrix", mvpMat);
capi.Render.CurrentActiveShader.Uniform("origin", new Vec3f());
}
else
{
prog = rapi.StandardShader;
prog.Use();
prog.WaterWave = 0;
prog.Tex2D = renderInfo.TextureId;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
BlockPos pos = entity.Pos.AsBlockPos;
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
int temp = (int)stack.Collectible.GetTemperature(capi.World, stack);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
lightrgbs[0] += 2 * glowColor[0];
lightrgbs[1] += 2 * glowColor[1];
lightrgbs[2] += 2 * glowColor[2];
prog.ExtraGlow = GameMath.Clamp((temp - 500) / 3, 0, 255);
prog.RgbaAmbientIn = rapi.AmbientColor;
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.RgbaFogIn = rapi.FogColor;
prog.FogMinIn = rapi.FogMin;
prog.FogDensityIn = rapi.FogDensity;
prog.ProjectionMatrix = rapi.CurrentProjectionMatrix;
prog.ViewMatrix = rapi.CameraMatrixOriginf;
prog.ModelMatrix = ItemModelMat.Values;
}
if (!renderInfo.CullFaces)
{
rapi.GlDisableCullFace();
}
rapi.RenderMesh(renderInfo.ModelRef);
if (!renderInfo.CullFaces)
{
rapi.GlEnableCullFace();
}
if (!isShadowPass)
{
prog.Stop();
}
}
