public virtual void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (loadedTexture == null)
{
return;
}
if (!api.Render.DefaultFrustumCuller.SphereInFrustum(pos.X + 0.5, pos.Y + 0.5, pos.Z + 0.5, 1))
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true, EnumBlendMode.PremultipliedAlpha);
IStandardShaderProgram prog = rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.Tex2D = loadedTexture.TextureId;
prog.NormalShaded = 0;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(translateX, translateY, translateZ)
.RotateY(rotY * GameMath.DEG2RAD)
.Translate(offsetX, offsetY, offsetZ)
.Scale(0.45f * QuadWidth, 0.45f * QuadHeight, 0.45f * QuadWidth)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.NormalShaded = 0;
prog.ExtraGodray = 0;
prog.SsaoAttn = 0;
prog.AlphaTest = 0.05f;
prog.OverlayOpacity = 0;
rpi.RenderMesh(quadModelRef);
prog.Stop();
rpi.GlToggleBlend(true, EnumBlendMode.Standard);
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (workItemMeshRef == null)
{
return;
}
if (stage == EnumRenderStage.AfterFinalComposition)
{
RenderRecipeOutLine();
return;
}
IRenderAPI rpi = api.Render;
IClientWorldAccessor worldAccess = api.World;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
EntityPos plrPos = worldAccess.Player.Entity.Pos;
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.ExtraGlow = 0;
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.WaterWave = 0;
rpi.BindTexture2d(texId);
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z).Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(workItemMeshRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (circuitMeshRef == null)
{
return;
}
timer = (timer + deltaTime) % period;
IRenderAPI rpi = capi.Render;
IClientWorldAccessor worldAccess = capi.World;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = capi.Render.PreparedStandardShader(pos.X, pos.Y, pos.Z);
rpi.BindTexture2d(texId);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.RgbaGlowIn = new Vec4f(1f, 1f, 1f, 1);
foreach (var item in wireMeshesRefs)
{
prog.ExtraGlow = networkStates.ContainsKey(item.Key)? (networkStates[item.Key] * 100 / 15):0;
rpi.RenderMesh(item.Value);
}
prog.ExtraGlow = 0;
rpi.RenderMesh(circuitMeshRef);
prog.Stop();
rpi.GlEnableCullFace();
}
private void RenderFallingBlockEntity(float x, float y, float z)
{
IRenderAPI rapi = capi.Render;
rapi.GlDisableCullFace();
rapi.GlToggleBlend(true, EnumBlendMode.Standard);
IStandardShaderProgram prog = rapi.PreparedStandardShader((int)entity.Pos.X, (int)entity.Pos.Y, (int)entity.Pos.Z);
Vec3d camPos = capi.World.Player.Entity.CameraPos;
prog.Tex2D = atlasTextureId;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(x - camPos.X, y - camPos.Y, z - camPos.Z)
.Values
;
prog.ViewMatrix = rapi.CameraMatrixOriginf;
prog.ProjectionMatrix = rapi.CurrentProjectionMatrix;
rapi.RenderMesh(meshRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (meshref == null || !ShouldRender)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.Tex2D = api.BlockTextureAtlas.AtlasTextureIds[0];
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(0.5f, 11f / 16f, 0.5f)
.RotateY(Angle * GameMath.DEG2RAD)
.Translate(-0.5f, 0, -0.5f)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(meshref);
prog.Stop();
if (ShouldRotate)
{
Angle += deltaTime * 40;
}
}
public virtual void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (loadedTexture == null)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true, EnumBlendMode.PremultipliedAlpha);
IStandardShaderProgram prog = rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.Tex2D = loadedTexture.TextureId;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.NormalShaded = 0;
prog.ExtraGodray = 0;
prog.SsaoAttn = 0;
prog.AlphaTest = 0.05f;
prog.OverlayOpacity = 0;
rpi.RenderMesh(quadModelRef);
prog.Stop();
rpi.GlToggleBlend(true, EnumBlendMode.Standard);
}
public override void DoRender3DOpaque(float dt, bool isShadowPass)
{
IRenderAPI rapi = capi.Render;
IEntityPlayer entityPlayer = capi.World.Player.Entity;
ItemRenderInfo renderInfo = rapi.GetItemStackRenderInfo(entityitem.Itemstack, EnumItemRenderTarget.Ground);
if (renderInfo.ModelRef == null)
{
return;
}
IStandardShaderProgram prog = null;
LoadModelMatrix(renderInfo, isShadowPass);
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;
if (entity.Swimming)
{
prog.WaterWave = entityitem.Itemstack.Collectible.MaterialDensity > 1000 ? 0 : 1;
prog.WaterWaveCounter = capi.Render.WaterWaveCounter;
prog.Playerpos = new Vec3f((float)entityPlayer.CameraPos.X, (float)entityPlayer.CameraPos.Y, (float)entityPlayer.CameraPos.Z);
}
else
{
prog.WaterWave = 0;
}
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);
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 = ModelMat;
}
if (!renderInfo.CullFaces)
{
rapi.GlDisableCullFace();
}
rapi.RenderMesh(renderInfo.ModelRef);
if (!renderInfo.CullFaces)
{
rapi.GlEnableCullFace();
}
if (!isShadowPass)
{
prog.Stop();
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (beAnvil.Inventory[0].Empty)
{
return;
}
IRenderAPI rpi = capi.Render;
Vec3d camPos = capi.World.Player.Entity.CameraPos;
int temp = (int)beAnvil.Inventory[0].Itemstack.Collectible.GetTemperature(capi.World, beAnvil.Inventory[0].Itemstack);
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(beAnvil.Pos.X, beAnvil.Pos.Y, beAnvil.Pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
int extraGlow = GameMath.Clamp((temp - 550) / 2, 0, 255);
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.PreparedStandardShader(beAnvil.Pos.X, beAnvil.Pos.Y, beAnvil.Pos.Z);
prog.Tex2D = capi.BlockTextureAtlas.AtlasTextureIds[0];
prog.ModelMatrix = ModelMat
.Identity()
.Translate(beAnvil.Pos.X - camPos.X, beAnvil.Pos.Y - camPos.Y, beAnvil.Pos.Z - camPos.Z)
.Values
;
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], extraGlow / 255f);
prog.ExtraGlow = extraGlow;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(beAnvil.BaseMeshRef);
if (beAnvil.FluxMeshRef != null)
{
prog.ExtraGlow = 0;
rpi.RenderMesh(beAnvil.FluxMeshRef);
}
if (beAnvil.TopMeshRef != null)
{
temp = (int)beAnvil.Inventory[2].Itemstack.Collectible.GetTemperature(capi.World, beAnvil.Inventory[2].Itemstack);
lightrgbs = capi.World.BlockAccessor.GetLightRGBs(beAnvil.Pos.X, beAnvil.Pos.Y, beAnvil.Pos.Z);
glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
extraGlow = GameMath.Clamp((temp - 550) / 2, 0, 255);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(beAnvil.Pos.X - camPos.X, beAnvil.Pos.Y - camPos.Y - beAnvil.hammerHits / 250f, beAnvil.Pos.Z - camPos.Z)
.Values
;
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], extraGlow / 255f);
prog.ExtraGlow = extraGlow;
rpi.RenderMesh(beAnvil.TopMeshRef);
}
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (stack == null && fuelLevel == 0)
{
return;
}
IRenderAPI rpi = capi.Render;
IClientWorldAccessor worldAccess = capi.World;
EntityPos plrPos = worldAccess.Player.Entity.Pos;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.WaterWave = 0;
//rpi.GlMatrixModeModelView();
if (stack != null && workItemMeshRef != null)
{
int temp = (int)stack.Collectible.GetTemperature(capi.World, stack);
prog.ExtraGlow = GameMath.Clamp((temp - 700) / 2, 0, 255);
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
lightrgbs[0] += 2 * glowColor[0];
lightrgbs[1] += 2 * glowColor[1];
lightrgbs[2] += 2 * glowColor[2];
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
// The work item
rpi.BindTexture2d(workItemTexPos.atlasTextureId);
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y + 7 / 16f + fuelLevel * 0.65f, pos.Z - camPos.Z).Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(workItemMeshRef);
}
if (fuelLevel > 0)
{
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.ExtraGlow = 0;
// The coal or embers
rpi.BindTexture2d(burning ? embertexpos.atlasTextureId : coaltexpos.atlasTextureId);
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y + 7 / 16f + fuelLevel * 0.65f, pos.Z - camPos.Z).Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(burning ? emberQuadRef : coalQuadRef);
}
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
IRenderAPI rpi = capi.Render;
Vec3d camPos = capi.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.Tex2D = capi.BlockTextureAtlas.AtlasTextureIds[0];
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.NormalShaded = 1;
prog.ExtraGodray = 0;
prog.SsaoAttn = 0;
prog.AlphaTest = 0.05f;
prog.OverlayOpacity = 0;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X + 0.001f, pos.Y - camPos.Y, pos.Z - camPos.Z - 0.001f)
.Translate(0f, 1 / 16f, 0f)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(potRef == null ? potWithFoodRef : potRef);
if (!isInOutputSlot)
{
float origx = GameMath.Sin(capi.World.ElapsedMilliseconds / 300f) * 5 / 16f;
float origz = GameMath.Cos(capi.World.ElapsedMilliseconds / 300f) * 5 / 16f;
float cookIntensity = GameMath.Clamp((temp - 50) / 50, 0, 1);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(0, 6.5f / 16f, 0)
.Translate(-origx, 0, -origz)
.RotateX(cookIntensity * GameMath.Sin(capi.World.ElapsedMilliseconds / 50f) / 60)
.RotateZ(cookIntensity * GameMath.Sin(capi.World.ElapsedMilliseconds / 50f) / 60)
.Translate(origx, 0, origz)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(lidRef);
}
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
IRenderAPI rpi = capi.Render;
IClientWorldAccessor worldAccess = capi.World;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
prog.ExtraGodray = 0;
prog.OverlayOpacity = 0;
Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
if (stack != null && workItemMeshRef != null)
{
int temp = (int)stack.Collectible.GetTemperature(capi.World, stack);
//Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
int extraGlow = GameMath.Clamp((temp - 550) / 2, 0, 255);
prog.NormalShaded = 1;
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], extraGlow / 255f);
prog.ExtraGlow = extraGlow;
prog.Tex2D = textureId;
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y + 10 / 16f, pos.Z - camPos.Z).Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(workItemMeshRef);
}
if (burning)
{
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(1200);
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], 1);
}
else
{
prog.RgbaGlowIn = new Vec4f(0, 0, 0, 0);
}
prog.NormalShaded = 1;
prog.RgbaLightIn = lightrgbs;
prog.ExtraGlow = burning ? 255 : 0;
rpi.BindTexture2d(hetexpos.atlasTextureId);
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z).Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(heQuadRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (contentStackRenderer != null)
{
contentStackRenderer.OnRenderFrame(deltaTime, stage);
return;
}
if (meshref == null)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.WaterWave = 0;
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
api.Render.BindTexture2d(api.ItemTextureAtlas.AtlasTextureIds[0]);
int temp = (int)ContentStack.Collectible.GetTemperature(api.World, ContentStack);
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
lightrgbs[0] += 2 * glowColor[0];
lightrgbs[1] += 2 * glowColor[1];
lightrgbs[2] += 2 * glowColor[2];
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.ExtraGlow = (int)GameMath.Clamp((temp - 500) / 4, 0, 255);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X + transform.Translation.X, pos.Y - camPos.Y + transform.Translation.Y, pos.Z - camPos.Z + transform.Translation.Z)
.Translate(transform.Origin.X, 0.6f + transform.Origin.Y, transform.Origin.Z)
.RotateX((90 + transform.Rotation.X) * GameMath.DEG2RAD)
.RotateY(transform.Rotation.Y * GameMath.DEG2RAD)
.RotateZ(transform.Rotation.Z * GameMath.DEG2RAD)
.Scale(transform.ScaleXYZ.X, transform.ScaleXYZ.Y, transform.ScaleXYZ.Z)
.Translate(-transform.Origin.X, -transform.Origin.Y, -transform.Origin.Z)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(meshref);
prog.Stop();
}
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();
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (Level <= 0 || TextureName == null)
{
return;
}
int voxelY = (int)GameMath.Clamp(Level, 0, fillQuadsByLevel.Length - 1);
IRenderAPI rpi = api.Render;
IClientWorldAccessor worldAccess = api.World;
EntityPos plrPos = worldAccess.Player.Entity.Pos;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f((int)Temperature);
lightrgbs.R += 2 * glowColor[0];
lightrgbs.G += 2 * glowColor[1];
lightrgbs.B += 2 * glowColor[2];
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.ExtraGlow = (int)GameMath.Clamp((Temperature - 500) / 4, 0, 255);
int texid = api.Render.GetOrLoadTexture(TextureName);
Cuboidf rect = fillQuadsByLevel[voxelY];
rpi.BindTexture2d(texid);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(1 - rect.X1 / 16f, 1.01f / 16f + Math.Max(0, Level / 16f - 0.0625f / 3), 1 - rect.Z1 / 16f)
.RotateX(90 * GameMath.DEG2RAD)
.Scale(0.5f * rect.Width / 16f, 0.5f * rect.Length / 16f, 0.5f)
.Translate(-1, -1, 0)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(quadModelRefs[voxelY]);
prog.Stop();
rpi.GlEnableCullFace();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
foreach (var player in API.World.AllPlayers)
{
// Leaving the additional, more detailed exceptions in just in case other things end up breaking.
if (player == null)
{
throw new Exception("null player in API.World.AllPlayers!");
}
// Player entity may be null in some circumstances.
// Maybe the other player is too far away, so there's
// no entity spawned for them on the client's side?
if (player.Entity == null)
{
continue;
}
if (API.World == null)
{
throw new Exception("API.World is null!");
}
if (API.World.Player == null)
{
throw new Exception("API.World.Player is null!");
}
// Don't render anything on the client player if they're in first person.
if ((API.World.Player.CameraMode == EnumCameraMode.FirstPerson) &&
(player == API.World.Player))
{
continue;
}
var entity = player.Entity;
var carried = entity.GetCarried();
if (carried == null)
{
continue;
}
var renderInfo = GetRenderInfo(carried);
var renderer = (EntityShapeRenderer)entity.Properties.Client.Renderer;
if (renderer == null)
{
continue; // Apparently this can end up being null?
}
// Reported to Tyron, so it might be fixed. Leaving it in for now just in case.
var animator = (BlendEntityAnimator)renderer.curAnimator;
if (animator == null)
{
throw new Exception("renderer.curAnimator is null!");
}
if (!animator.AttachmentPointByCode.TryGetValue("Back", out var pose))
{
return;
}
var renderApi = API.Render;
var isShadowPass = (stage != EnumRenderStage.Opaque);
var modelMat = Mat4f.CloneIt(renderer.ModelMat);
var viewMat = Array.ConvertAll(API.Render.CameraMatrixOrigin, i => (float)i);
var animModelMat = pose.Pose.AnimModelMatrix;
Mat4f.Mul(modelMat, modelMat, animModelMat);
IStandardShaderProgram prog = null;
if (isShadowPass)
{
renderApi.CurrentActiveShader.BindTexture2D("tex2d", renderInfo.TextureId, 0);
}
else
{
prog = renderApi.PreparedStandardShader((int)entity.Pos.X, (int)entity.Pos.Y, (int)entity.Pos.Z);
prog.Tex2D = renderInfo.TextureId;
prog.AlphaTest = 0.01f;
}
// Apply attachment point transform.
var attach = pose.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);
// Apply carried block's behavior transform.
var t = renderInfo.Transform;
Mat4f.Scale(modelMat, modelMat, t.ScaleXYZ.X, t.ScaleXYZ.Y, t.ScaleXYZ.Z);
Mat4f.Translate(modelMat, modelMat, _impliedOffset.X, _impliedOffset.Y, _impliedOffset.Z);
Mat4f.Translate(modelMat, modelMat, t.Origin.X, t.Origin.Y, t.Origin.Z);
Mat4f.RotateX(modelMat, modelMat, t.Rotation.X * GameMath.DEG2RAD);
Mat4f.RotateY(modelMat, modelMat, t.Rotation.Y * GameMath.DEG2RAD);
Mat4f.RotateZ(modelMat, modelMat, t.Rotation.Z * GameMath.DEG2RAD);
Mat4f.Translate(modelMat, modelMat, -t.Origin.X, -t.Origin.Y, -t.Origin.Z);
Mat4f.Translate(modelMat, modelMat, t.Translation.X, t.Translation.Y, t.Translation.Z);
if (isShadowPass)
{
Mat4f.Mul(modelMat, API.Render.CurrentShadowProjectionMatrix, modelMat);
API.Render.CurrentActiveShader.UniformMatrix("mvpMatrix", modelMat);
API.Render.CurrentActiveShader.Uniform("origin", renderer.OriginPos);
}
else
{
prog.ModelMatrix = modelMat;
prog.ViewMatrix = viewMat;
}
API.Render.RenderMesh(renderInfo.ModelRef);
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);
}
}
}
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (LevelLeft <= 0 && LevelRight <= 0)
{
return;
}
IRenderAPI rpi = api.Render;
IClientWorldAccessor worldAccess = api.World;
EntityPos plrPos = worldAccess.Player.Entity.Pos;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.DontWarpVertices = 0;
prog.ExtraGodray = 0;
prog.AddRenderFlags = 0;
if (LevelLeft > 0 && TextureNameLeft != null)
{
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f((int)TemperatureLeft);
int extraGlow = (int)GameMath.Clamp((TemperatureLeft - 550) / 1.5f, 0, 255);
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], extraGlow / 255f);
prog.ExtraGlow = extraGlow;
prog.NormalShaded = 0;
int texid = api.Render.GetOrLoadTexture(TextureNameLeft);
rpi.BindTexture2d(texid);
float xzOffset = (QuantityMolds > 1) ? 4.5f : 8.5f;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(xzOffset / 16f, 1 / 16f + LevelLeft / 850f, 8.5f / 16)
.RotateX(90 * GameMath.DEG2RAD)
.Scale(0.5f * 3 / 16f, 0.5f * 7 / 16f, 0.5f)
.Values
;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
rpi.RenderMesh(quadModelRef);
}
if (LevelRight > 0 && QuantityMolds > 1 && TextureNameRight != null)
{
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f((int)TemperatureRight);
int extraGlow = (int)GameMath.Clamp((TemperatureRight - 550) / 1.5f, 0, 255);
prog.RgbaLightIn = lightrgbs;
prog.RgbaGlowIn = new Vec4f(glowColor[0], glowColor[1], glowColor[2], extraGlow / 255f);
prog.ExtraGlow = extraGlow;
prog.NormalShaded = 0;
int texid = api.Render.GetOrLoadTexture(TextureNameRight);
rpi.BindTexture2d(texid);
/*
* rpi.GlPushMatrix();
* rpi.GlLoadMatrix(api.Render.CameraMatrixOrigin);
* rpi.GlTranslate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z);
* rpi.GlTranslate(11.5f / 16f, 1 / 16f + LevelRight / 850f, 8.5f / 16);
* rpi.GlRotate(90, 1, 0, 0);
* rpi.GlScale(0.5f * 3 / 16f, 0.5f * 7 / 16f, 0.5f);
* prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
* prog.ModelViewMatrix = rpi.CurrentModelviewMatrix;
* rpi.GlPopMatrix();
*/
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(11.5f / 16f, 1 / 16f + LevelRight / 850f, 8.5f / 16)
.RotateX(90 * GameMath.DEG2RAD)
.Scale(0.5f * 3 / 16f, 0.5f * 7 / 16f, 0.5f)
.Values
;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
rpi.RenderMesh(quadModelRef);
}
prog.Stop();
rpi.GlEnableCullFace();
}
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();
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (needleMeshRef == null || discMeshRef == null)
{
return;
}
long ellapsedMs = api.World.ElapsedMilliseconds;
IRenderAPI rpi = api.Render;
IClientWorldAccessor worldAccess = api.World;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.ExtraGlow = 0;
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.RgbaLightIn = lightrgbs;
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
prog.ExtraGodray = 0;
prog.NormalShaded = 1;
rpi.BindTexture2d(api.BlockTextureAtlas.AtlasTextureIds[0]);
float origx = -0.5f;
float origz = -0.5f;
needlePos.X = 3.5f / 16f;
needlePos.Y = 10.8f / 16f;
needlePos.Z = -3.5f / 16f;
// because i'm a noob and lazy
switch (blockRotation)
{
case 90: needlePos.X -= 7 / 16f; break;
case 180: needlePos.X -= 7 / 16f; needlePos.Z += 7 / 16f; break;
case 270: needlePos.Z += 7 / 16f; break;
}
float wobble = GameMath.Sin(Math.Max(0, ellapsedMs - updatedTotalMs) / 50f - 0.5f) / 80f;
needleRotRad.Y = -GameMath.PIHALF + Math.Min(0.4f, (ellapsedMs - updatedTotalMs) / 700f) + wobble + blockRotation * GameMath.DEG2RAD;
needleRotRad.X = wobble;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X + needlePos.X, pos.Y - camPos.Y + needlePos.Y, pos.Z - camPos.Z + needlePos.Z)
.Translate(-origx, 0, -origz)
.Rotate(needleRotRad)
.Translate(origx, 0, origz)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(needleMeshRef);
rpi.BindTexture2d(api.ItemTextureAtlas.AtlasTextureIds[0]);
origx = -9.25f / 16f;
float origy = -9.5f / 16f;
origz = -0.5f;
discPos.X = -1.25f / 16f;
discPos.Y = 11.2f / 16f;
discPos.Z = 0f / 16f;
discRotRad.X = GameMath.PIHALF;
discRotRad.Z = -Math.Max(0, (ellapsedMs - updatedTotalMs) / 500f - 0.5f);
prog.NormalShaded = 0;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X + discPos.X, pos.Y - camPos.Y + discPos.Y, pos.Z - camPos.Z + discPos.Z)
.Translate(-origx, 0, -origz)
.Rotate(discRotRad)
.Scale(0.45f, 0.45f, 0.45f)
.Translate(origx, origy, origz)
.Values
;
rpi.RenderMesh(discMeshRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (meshref == null || !ShouldRender)
{
return;
}
IRenderAPI rpi = Api.Render;
Vec3d camPos = Api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.PreparedStandardShader(Pos.X, Pos.Y, Pos.Z);
prog.Tex2D = Api.BlockTextureAtlas.AtlasTextureIds[0];
prog.ModelMatrix = ModelMat
.Identity()
.Translate(Pos.X - camPos.X, Pos.Y - camPos.Y, Pos.Z - camPos.Z)
.Translate(0.5f, 11f / 16f, 0.5f)
.RotateY(Angle)
.Translate(-0.5f, 0, -0.5f)
.Translate(xf, yf, zf)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(meshref);
prog.Stop();
if (ShouldRotate)
{
float jl = (int)Api.World.Rand.NextDouble();
if (yb && yf <= 0.5f)
{
xf += deltaTime * 0.02f;
yf += deltaTime * jl * 5.0f;
zf += deltaTime * 0.02f;
}
else
{
yb = false;
if (dO && Api.Side == EnumAppSide.Client)
{
Api.World.PlaySoundAt(CrushSound, Pos.X, Pos.Y, Pos.Z);
dO = false;
}
}
if (!yb && yf >= -0.2f)
{
xf -= deltaTime * 0.04f;
yf -= deltaTime * jl * 10.0f;
zf -= deltaTime * 0.04f;
}
else
{
yb = true; dO = true;
}
if (!yb)
{
Angle += (deltaTime * 100) * GameMath.DEG2RAD;
}
if (Angle * GameMath.RAD2DEG > 360.0f)
{
Angle = 0.0f * GameMath.DEG2RAD;
}
}
else
{
xf = 0.0f;
yf = 0.0f;
zf = 0.0f;
Angle = 0.0f;
}
}
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();
}
}
