public Vec4d TransformVector(Vec4d vec)
{
Vec4d outval = new Vec4d();
Mat4f.MulWithVec4(Values, vec, outval);
return(outval);
}
void updateLocalEyePosImmersiveFpMode()
{
AttachmentPointAndPose apap = AnimManager.Animator.GetAttachmentPointPose("Eyes");
AttachmentPoint ap = apap.AttachPoint;
float[] ModelMat = Mat4f.Create();
Matrixf tmpModelMat = new Matrixf();
float bodyYaw = BodyYaw;
float rotX = Properties.Client.Shape != null ? Properties.Client.Shape.rotateX : 0;
float rotY = Properties.Client.Shape != null ? Properties.Client.Shape.rotateY : 0;
float rotZ = Properties.Client.Shape != null ? Properties.Client.Shape.rotateZ : 0;
float bodyPitch = WalkPitch;
float lookOffset = (SidedPos.Pitch - GameMath.PI) / 9f;
bool wasHoldPos = holdPosition;
holdPosition = false;
for (int i = 0; i < AnimManager.Animator.RunningAnimations.Length; i++)
{
RunningAnimation anim = AnimManager.Animator.RunningAnimations[i];
if (anim.Running && anim.EasingFactor > anim.meta.HoldEyePosAfterEasein)
{
if (!wasHoldPos)
{
prevAnimModelMatrix = (float[])apap.AnimModelMatrix.Clone();
}
holdPosition = true;
break;
}
}
tmpModelMat
.Set(ModelMat)
.RotateX(SidedPos.Roll + rotX * GameMath.DEG2RAD)
.RotateY(bodyYaw + (180 + rotY) * GameMath.DEG2RAD)
.RotateZ(bodyPitch + rotZ * GameMath.DEG2RAD)
.Mul(holdPosition ? prevAnimModelMatrix : apap.AnimModelMatrix)
.Scale(Properties.Client.Size, Properties.Client.Size, Properties.Client.Size)
.Translate(-0.5f, 0, -0.5f)
.Translate(ap.PosX / 16f - lookOffset, ap.PosY / 16f - lookOffset / 1.3f, ap.PosZ / 16f)
;
float[] pos = new float[4] {
0, 0, 0, 1
};
float[] endVec = Mat4f.MulWithVec4(tmpModelMat.Values, pos);
LocalEyePos.Set(endVec[0], endVec[1], endVec[2]);
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
// before rendering: update our values
Mat4f.Invert(InvProjectionMatrix, _mod.CApi.Render.CurrentProjectionMatrix);
Mat4f.Invert(InvModelViewMatrix, _mod.CApi.Render.CameraMatrixOriginf);
_tempVec4f.Set(0, 0, 0, 1);
Mat4f.MulWithVec4(InvModelViewMatrix, _tempVec4f, CameraWorldPosition);
DayLight = 1.25f * GameMath.Max(
_mod.CApi.World.Calendar.DayLightStrength -
_mod.CApi.World.Calendar.MoonLightStrength / 2f, 0.05f);
}
public static void RotateVector(ref Vec3f vector, float degX, float degY, float degZ, Vec3f origin)
{
float radX = degX * GameMath.DEG2RAD;
float radY = degY * GameMath.DEG2RAD;
float radZ = degZ * GameMath.DEG2RAD;
float[] matrix = Mat4f.Create();
Mat4f.RotateX(matrix, matrix, radX);
Mat4f.RotateY(matrix, matrix, radY);
Mat4f.RotateZ(matrix, matrix, radZ);
float[] pos = new float[] { 0, 0, 0, 1 };
float[] vec = new float[] { vector.X - (float)origin.X, vector.Y - (float)origin.Y, vector.Z - (float)origin.Z, 1 };
vec = Mat4f.MulWithVec4(matrix, vec);
vector.X = vec[0] + origin.X;
vector.Y = vec[1] + origin.Y;
vector.Z = vec[2] + origin.Z;
}
/// <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);
}
public override void DoRender3DOpaque(float dt, bool isShadowPass)
{
IRenderAPI rapi = capi.Render;
// the value 22 is just trial&error, should probably be something proportial to the
// 13ms game ticks (which is the physics frame rate)
lerpedPos.X += (entity.Pos.X - lerpedPos.X) * 22 * dt;
lerpedPos.Y += (entity.Pos.Y - lerpedPos.Y) * 22 * dt;
lerpedPos.Z += (entity.Pos.Z - lerpedPos.Z) * 22 * dt;
ItemRenderInfo renderInfo = rapi.GetItemStackRenderInfo(inslot, EnumItemRenderTarget.Ground);
if (renderInfo.ModelRef == null)
{
return;
}
inslot.Itemstack.Collectible.OnBeforeRender(capi, inslot.Itemstack, EnumItemRenderTarget.Ground, ref renderInfo);
IStandardShaderProgram prog = null;
LoadModelMatrix(renderInfo, isShadowPass, dt);
if (isShadowPass)
{
rapi.CurrentActiveShader.BindTexture2D("tex2d", renderInfo.TextureId, 0);
float[] mvpMat = Mat4f.Mul(ModelMat, capi.Render.CurrentModelviewMatrix, ModelMat);
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.Tex2D = renderInfo.TextureId;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.DontWarpVertices = 0;
prog.NormalShaded = 1;
if (entity.Swimming)
{
prog.AddRenderFlags = (entityitem.Itemstack.Collectible.MaterialDensity > 1000 ? 0 : 1) << 12;
prog.WaterWaveCounter = capi.Render.ShaderUniforms.WaterWaveCounter;
}
else
{
prog.AddRenderFlags = 0;
}
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(entityitem.Itemstack);
prog.BaseUvOrigin = new Vec2f(texPos.x1, texPos.y1);
}
BlockPos pos = entityitem.Pos.AsBlockPos;
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
int temp = (int)entityitem.Itemstack.Collectible.GetTemperature(capi.World, entityitem.Itemstack);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
int extraGlow = GameMath.Clamp((temp - 550) / 2, 0, 255);
glowRgb.R = glowColor[0];
glowRgb.G = glowColor[1];
glowRgb.B = glowColor[2];
glowRgb.A = extraGlow / 255f;
prog.ExtraGlow = extraGlow;
prog.RgbaAmbientIn = rapi.AmbientColor;
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = glowRgb;
prog.RgbaFogIn = rapi.FogColor;
prog.FogMinIn = rapi.FogMin;
prog.FogDensityIn = rapi.FogDensity;
prog.ExtraGodray = 0;
prog.NormalShaded = renderInfo.NormalShaded ? 1 : 0;
prog.ProjectionMatrix = rapi.CurrentProjectionMatrix;
prog.ViewMatrix = rapi.CameraMatrixOriginf;
prog.ModelMatrix = ModelMat;
ItemStack stack = entityitem.Itemstack;
AdvancedParticleProperties[] ParticleProperties = stack.Block?.ParticleProperties;
if (stack.Block != null && !capi.IsGamePaused)
{
Mat4f.MulWithVec4(ModelMat, new Vec4f(stack.Block.TopMiddlePos.X, stack.Block.TopMiddlePos.Y - 0.4f, stack.Block.TopMiddlePos.Z - 0.5f, 0), particleOutTransform); // No idea why the -0.5f and -0.4f
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 = particleOutTransform.X + entity.Pos.X;
bps.basePos.Y = particleOutTransform.Y + entity.Pos.Y;
bps.basePos.Z = particleOutTransform.Z + entity.Pos.Z;
entityitem.World.SpawnParticles(bps);
}
}
}
}
if (!renderInfo.CullFaces)
{
rapi.GlDisableCullFace();
}
rapi.RenderMesh(renderInfo.ModelRef);
if (!renderInfo.CullFaces)
{
rapi.GlEnableCullFace();
}
if (!isShadowPass)
{
prog.Stop();
}
}
