public 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);
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)
.Translate(translateX, 0.5625f, translateZ)
.RotateY(rotY * GameMath.DEG2RAD)
.Scale(0.45f * QuadWidth, 0.45f * QuadHeight, 0.45f * QuadWidth)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(quadModelRef);
prog.Stop();
}
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;
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.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;
rpi.RenderMesh(workItemMeshRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
capi.Render.GlToggleBlend(true);
IShaderProgram curShader = capi.Render.CurrentActiveShader;
curShader?.Stop();
foreach (var prog in progs)
{
if (prog.Disposed)
{
continue;
}
prog.Use();
prog.SetDefaultUniforms(capi);
prog.BindTexture2D("iDepthBuffer", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].DepthTextureId, 0);
prog.BindTexture2D("iColor", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].ColorTextureIds[0], 1);
prog.BindTexture2D("iLight", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].ColorTextureIds[1], 2);
prog.BindTexture2D("iGodrays", capi.Render.FrameBuffers[(int)EnumFrameBuffer.GodRays].ColorTextureIds[0], 3);
prog.BindTexture2D("iShadowMapNear", capi.Render.FrameBuffers[(int)EnumFrameBuffer.ShadowmapNear].DepthTextureId, 4);
prog.BindTexture2D("iShadowMapFar", capi.Render.FrameBuffers[(int)EnumFrameBuffer.ShadowmapFar].DepthTextureId, 5);
capi.Render.RenderMesh(quadRef);
prog.Stop();
}
curShader?.Use();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (Level <= 0 || capi.World.Player.CameraMode != EnumCameraMode.FirstPerson)
{
return;
}
if (Level > 0.2 && capi.World.Rand.Next(60) == 0)
{
rndTarget = (float)capi.World.Rand.NextDouble() / 5f - 1 / 10f;
}
curRndVal += (rndTarget - curRndVal) * deltaTime;
IShaderProgram curShader = capi.Render.CurrentActiveShader;
curShader.Stop();
eyeShaderProg.Use();
capi.Render.GlToggleBlend(true);
eyeShaderProg.Uniform("level", Level + curRndVal);
capi.Render.RenderMesh(quadRef);
eyeShaderProg.Stop();
curShader.Use();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (workItemMeshRef == null)
{
return;
}
if (stage == EnumRenderStage.AfterFinalComposition)
{
if (api.World.Player?.InventoryManager?.ActiveHotbarSlot?.Itemstack?.Collectible is ItemHammer)
{
RenderRecipeOutLine();
}
return;
}
IRenderAPI rpi = api.Render;
IClientWorldAccessor worldAccess = api.World;
Vec3d camPos = worldAccess.Player.Entity.CameraPos;
int temp = (int)ingot.Collectible.GetTemperature(api.World, ingot);
Vec4f lightrgbs = worldAccess.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
int extraGlow = GameMath.Clamp((temp - 550) / 2, 0, 255);
float[] glowColor = ColorUtil.GetIncandescenceColorAsColor4f(temp);
glowRgb.R = glowColor[0];
glowRgb.G = glowColor[1];
glowRgb.B = glowColor[2];
glowRgb.A = extraGlow / 255f;
rpi.GlDisableCullFace();
IShaderProgram prog = coreMod.anvilShaderProg;
prog.Use();
rpi.BindTexture2d(texId);
prog.Uniform("rgbaAmbientIn", rpi.AmbientColor);
prog.Uniform("rgbaFogIn", rpi.FogColor);
prog.Uniform("fogMinIn", rpi.FogMin);
prog.Uniform("dontWarpVertices", (int)0);
prog.Uniform("addRenderFlags", (int)0);
prog.Uniform("fogDensityIn", rpi.FogDensity);
prog.Uniform("rgbaTint", ColorUtil.WhiteArgbVec);
prog.Uniform("rgbaLightIn", lightrgbs);
prog.Uniform("rgbaGlowIn", glowRgb);
prog.Uniform("extraGlow", extraGlow);
prog.UniformMatrix("modelMatrix", ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Values
);
prog.UniformMatrix("viewMatrix", rpi.CameraMatrixOriginf);
prog.UniformMatrix("projectionMatrix", rpi.CurrentProjectionMatrix);
rpi.RenderMesh(workItemMeshRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
foreach (var player in API.World.AllPlayers)
{
// Player entity may be null in some circumstances..?
if (player.Entity == null)
{
continue;
}
var isLocalPlayer = (player == API.World.Player);
var isShadowPass = (stage != EnumRenderStage.Opaque);
// Fix up animations that should/shouldn't be playing.
if (isLocalPlayer)
{
AnimationFixer.Update(player.Entity);
}
// Don't render if entity hasn't been rendered for the
// specified render stage (unless it's the local player).
else if (isShadowPass ? !player.Entity.IsShadowRendered
: !player.Entity.IsRendered)
{
continue;
}
RenderAllCarried(player.Entity, deltaTime, isShadowPass);
}
_renderTick++;
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (backPackMeshRef == null)
{
Block block = api.World.GetBlock(new AssetLocation("stationarybasket-north"));
backPackMeshRef = api.Render.UploadMesh(api.TesselatorManager.GetDefaultBlockMesh(block));
backPackTextureId = api.BlockTextureAtlas.Positions[0].atlasTextureId;
backPackTransform.Origin = block.GuiTransform.Origin;
}
for (int i = 0; i < api.World.AllPlayers.Length; i++)
{
IPlayer plr = api.World.AllPlayers[i];
EntityShapeRenderer rend = plr.Entity.Properties.Client.Renderer as EntityShapeRenderer;
if (rend == null)
{
continue;
}
if (plr == api.World.Player && api.World.Player.CameraMode == EnumCameraMode.FirstPerson)
{
continue;
}
RenderBackPack(plr.Entity, rend, stage != EnumRenderStage.Opaque);
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (voxelHeight == 0)
{
return;
}
IStandardShaderProgram prog = api.Render.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.ExtraGlow = glowLevel;
prog.RgbaBlockIn = new Vec4f(1 + glowLevel / 128f, 1 + glowLevel / 128f, 1 + glowLevel / 512f, 1);
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.BindTexture2d(textureId);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(8 / 16f + pos.X - camPos.X, pos.Y - camPos.Y + voxelHeight / 24f, 8 / 16f + pos.Z - camPos.Z)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(cubeModelRef);
prog.Stop();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (prog.Disposed)
{
prog = capi.Shader.GetProgramByName("instanced");
}
capi.Render.GlDisableCullFace();
if (stage == EnumRenderStage.Opaque)
{
capi.Render.GlToggleBlend(false); // Seems to break SSAO without
prog.Use();
prog.BindTexture2D("tex", capi.ItemTextureAtlas.Positions[0].atlasTextureId, 0);
prog.Uniform("rgbaFogIn", capi.Render.FogColor);
prog.Uniform("rgbaAmbientIn", capi.Render.AmbientColor);
prog.Uniform("fogMinIn", capi.Render.FogMin);
prog.Uniform("fogDensityIn", capi.Render.FogDensity);
prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
prog.UniformMatrix("modelViewMatrix", capi.Render.CameraMatrixOriginf);
foreach (var val in renderers)
{
val.Value.OnRenderFrame(deltaTime, prog);
}
prog.Stop();
}
capi.Render.GlEnableCullFace();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
UpdateCustomFloatBuffer();
prog.Use();
prog.BindTexture2D("tex", capi.BlockTextureAtlas.Positions[0].atlasTextureId, 0);
prog.Uniform("rgbaFogIn", capi.Render.FogColor);
prog.Uniform("rgbaAmbientIn", capi.Render.AmbientColor);
prog.Uniform("fogMinIn", capi.Render.FogMin);
prog.Uniform("fogDensityIn", capi.Render.FogDensity);
prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
prog.UniformMatrix("modelViewMatrix", capi.Render.CameraMatrixOriginf);
if (quantityGearboxes > 0)
{
floatsPeg.Count = quantityGearboxes * 20;
floatsCage.Count = quantityGearboxes * 20;
updateMesh.CustomFloats = floatsPeg;
capi.Render.UpdateMesh(gearboxPeg, updateMesh);
updateMesh.CustomFloats = floatsCage;
capi.Render.UpdateMesh(gearboxCage, updateMesh);
capi.Render.RenderMeshInstanced(gearboxPeg, quantityGearboxes);
capi.Render.RenderMeshInstanced(gearboxCage, quantityGearboxes);
}
prog.Stop();
/*capi.Render.RenderMeshInstanced(gearboxCage, quantityGearboxes);
* capi.Render.RenderMeshInstanced(axle, quantityAxles);
* capi.Render.RenderMeshInstanced(windmillRotor, quantityRotors);*/
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (meshref == null)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.PreparedStandardShader(compassPos.X, compassPos.Y, compassPos.Z);
prog.Tex2D = api.BlockTextureAtlas.AtlasTextureIds[0];
// TODO: Decouple from BlockCompass
var renderAngle = AngleRad ?? BlockCompass.GetWildSpinAngle(api);
prog.ModelMatrix = ModelMat
.Identity()
.Translate(compassPos.X - camPos.X, compassPos.Y - camPos.Y, compassPos.Z - camPos.Z)
.Translate(0.5f, 11f / 16f, 0.5f)
.RotateY(renderAngle)
.Translate(-0.5f, -11f / 16f, -0.5f)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(meshref);
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.WaterWave = 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 dt, EnumRenderStage stage)
{
if (updateMesh == null)
{
return;
}
tickPhysics(dt);
int count = 0;
updateMesh.CustomFloats.Count = 0;
foreach (var val in clothSystems)
{
if (!val.Value.Active)
{
continue;
}
count += val.Value.UpdateMesh(updateMesh, dt);
updateMesh.CustomFloats.Count = count * (4 + 16);
}
if (count > 0)
{
//float dt = 1.5f * deltaTime;
if (prog.Disposed)
{
prog = capi.Shader.GetProgramByName("instanced");
}
capi.Render.GlToggleBlend(false); // Seems to break SSAO without
prog.Use();
prog.BindTexture2D("tex", capi.ItemTextureAtlas.Positions[0].atlasTextureId, 0);
prog.Uniform("rgbaFogIn", capi.Render.FogColor);
prog.Uniform("rgbaAmbientIn", capi.Render.AmbientColor);
prog.Uniform("fogMinIn", capi.Render.FogMin);
prog.Uniform("fogDensityIn", capi.Render.FogDensity);
prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
prog.UniformMatrix("modelViewMatrix", capi.Render.CameraMatrixOriginf);
updateMesh.CustomFloats.Count = count * (4 + 16);
capi.Render.UpdateMesh(ropeMeshRef, updateMesh);
capi.Render.RenderMeshInstanced(ropeMeshRef, count);
prog.Stop();
}
foreach (var val in clothSystems)
{
if (!val.Value.Active)
{
continue;
}
val.Value.CustomRender(dt);
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (capi.IsGamePaused)
{
return;
}
onPhysicsTick(deltaTime);
}
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;
int temp = (int)ingot.Collectible.GetTemperature(api.World, ingot);
Vec4f lightrgbs = worldAccess.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];
rpi.GlDisableCullFace();
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
rpi.BindTexture2d(texId);
prog.RgbaAmbientIn = rpi.AmbientColor;
prog.RgbaFogIn = rpi.FogColor;
prog.FogMinIn = rpi.FogMin;
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 0;
prog.FogDensityIn = rpi.FogDensity;
prog.RgbaTint = ColorUtil.WhiteArgbVec;
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
prog.ExtraGlow = GameMath.Clamp((temp - 700) / 2, 0, 255);
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 (capi.IsGamePaused)
{
return;
}
foreach (MechanicalNetwork network in data.networksById.Values)
{
network.ClientTick(deltaTime);
}
}
// Needs to render mash, juice quad and bucket
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (mashMeshref == null || mashMeshref.Disposed)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
rpi.GlToggleBlend(true);
IStandardShaderProgram prog = rpi.StandardShader;
prog.Use();
prog.Tex2D = api.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;
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
prog.RgbaLightIn = lightrgbs;
double squeezeRel = befruitpress.MashSlot.Itemstack?.Attributes?.GetDouble("squeezeRel", 1) ?? 1;
prog.ModelMatrix = ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.Translate(0, 0.8f, 0)
.Scale(1, (float)squeezeRel, 1)
.Values
;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(mashMeshref);
prog.Stop();
}
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 void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
var rend = Api.Render;
var shader = rend.CurrentActiveShader;
_circleAlpha = Math.Max(0.0F, Math.Min(1.0F, _circleAlpha
+ deltaTime / (CircleVisible ? Settings.AlphaIn : -Settings.AlphaOut)));
// TODO: Do some smoothing between frames?
if ((CircleProgress <= 0.0F) || (_circleAlpha <= 0.0F))
{
return;
}
UpdateCirceMesh(CircleProgress);
var r = ((Settings.Color >> 16) & 0xFF) / 255.0F;
var g = ((Settings.Color >> 8) & 0xFF) / 255.0F;
var b = (Settings.Color & 0xFF) / 255.0F;
var color = new Vec4f(r, g, b, _circleAlpha);
shader.Uniform("rgbaIn", color);
shader.Uniform("extraGlow", 0);
shader.Uniform("applyColor", 0);
shader.Uniform("tex2d", 0);
shader.Uniform("noTexture", 1.0F);
shader.UniformMatrix("projectionMatrix", rend.CurrentProjectionMatrix);
int x, y;
if (Api.Input.MouseGrabbed)
{
x = Api.Render.FrameWidth / 2;
y = Api.Render.FrameHeight / 2;
}
else
{
x = Api.Input.MouseX;
y = Api.Input.MouseY;
}
// These IRenderAPI methods are deprecated but not sure how to do it otherwise.
#pragma warning disable CS0618
rend.GlPushMatrix();
rend.GlTranslate(x, y, 0);
rend.GlScale(Settings.OuterRadius, Settings.OuterRadius, 0);
shader.UniformMatrix("modelViewMatrix", rend.CurrentModelviewMatrix);
rend.GlPopMatrix();
#pragma warning restore CS0618
rend.RenderMesh(_circleMesh);
}
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);
capi.Render.BindTexture2d(capi.BlockTextureAtlas.AtlasTextureIds[0]);
prog.DontWarpVertices = 0;
prog.AddRenderFlags = 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);
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)
{
if (meshref == null || be.HammerStack == null)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
rpi.GlDisableCullFace();
float rotY = be.facing.HorizontalAngleIndex * 90;
float offx = be.facing == BlockFacing.NORTH || be.facing == BlockFacing.WEST ? -1 / 16f : 17 / 16f;
ModelMat
.Identity()
.Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
.RotateYDeg(rotY)
.Translate(offx, 12.5f / 16f, 0.5f)
.RotateZ(AngleRad)
.Translate(-offx, -12.5f / 16f, -0.5f)
.RotateYDeg(-rotY)
;
if (stage == EnumRenderStage.Opaque)
{
IStandardShaderProgram prog = rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);
prog.Tex2D = api.BlockTextureAtlas.AtlasTextureIds[0];
prog.ModelMatrix = ModelMat.Values;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
rpi.RenderMesh(meshref);
prog.Stop();
AngleRad = be.Angle;
}
else
{
IRenderAPI rapi = api.Render;
shadowMvpMat.Set(rapi.CurrentProjectionMatrix).Mul(rapi.CurrentModelviewMatrix).Mul(ModelMat.Values);
rapi.CurrentActiveShader.BindTexture2D("tex2d", api.BlockTextureAtlas.AtlasTextureIds[0], 0);
rapi.CurrentActiveShader.UniformMatrix("mvpMatrix", shadowMvpMat.Values);
rapi.CurrentActiveShader.Uniform("origin", new Vec3f());
rpi.RenderMesh(meshref);
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (prog.Disposed)
{
prog = capi.Shader.GetProgramByName("instanced");
}
capi.Render.GlDisableCullFace();
if (stage == EnumRenderStage.Opaque)
{
capi.Render.GlToggleBlend(false); // Seems to break SSAO without
prog.Use();
prog.BindTexture2D("tex", capi.BlockTextureAtlas.Positions[0].atlasTextureId, 0);
prog.Uniform("rgbaFogIn", capi.Render.FogColor);
prog.Uniform("rgbaAmbientIn", capi.Render.AmbientColor);
prog.Uniform("fogMinIn", capi.Render.FogMin);
prog.Uniform("fogDensityIn", capi.Render.FogDensity);
prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
prog.UniformMatrix("modelViewMatrix", capi.Render.CameraMatrixOriginf);
for (int i = 0; i < MechBlockRenderer.Count; i++)
{
MechBlockRenderer[i].OnRenderFrame(deltaTime, prog);
}
prog.Stop();
}
else
{
// TODO: Needs a custom shadow map shader
/*IRenderAPI rapi = capi.Render;
* rapi.CurrentActiveShader.BindTexture2D("tex2d", capi.BlockTextureAtlas.Positions[0].atlasTextureId, 0);
*
* float[] mvpMat = Mat4f.Mul(Mat4f.Create(), capi.Render.CurrentProjectionMatrix, capi.Render.CurrentModelviewMatrix);
*
* capi.Render.CurrentActiveShader.UniformMatrix("mvpMatrix", mvpMat);
* //capi.Render.CurrentActiveShader.Uniform("origin", new Vec3f());
*
* for (int i = 0; i < MechBlockRenderer.Count; i++)
* {
* MechBlockRenderer[i].OnRenderFrame(deltaTime, prog);
* }*/
}
capi.Render.GlEnableCullFace();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (capi.IsGamePaused)
{
return;
}
// Graceful degradation of the simulation quality instead of heavily lagging the game
accum += deltaTime;
if (accum > clientPhysicsTickTimeThreshold)
{
onPhysicsTick(deltaTime);
accum = 0f;
}
}
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;
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.WaterWave = 0;
Vec4f lightrgbs = api.World.BlockAccessor.GetLightRGBs(pos.X, pos.Y, pos.Z);
prog.RgbaLightIn = lightrgbs;
prog.RgbaBlockIn = ColorUtil.WhiteArgbVec;
rpi.BindTexture2d(texId);
prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
prog.ViewMatrix = rpi.CameraMatrixOriginf;
prog.ModelMatrix = ModelMat.Identity().Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z).Values;
rpi.RenderMesh(workItemMeshRef);
prog.Stop();
}
public void OnRenderFrame(float dt, EnumRenderStage stage)
{
simLightning.OnRenderFrame(dt, stage);
if (stage == EnumRenderStage.Before)
{
EntityPlayer eplr = capi.World.Player.Entity;
plrPos.Set((int)eplr.Pos.X, (int)eplr.Pos.Y, (int)eplr.Pos.Z);
plrPosd.Set(eplr.Pos.X, eplr.Pos.Y, eplr.Pos.Z);
WeatherDataAtPlayer.LoadAdjacentSimsAndLerpValues(plrPosd, dt);
WeatherDataAtPlayer.UpdateAdjacentAndBlendWeatherData();
int lightlevel = Math.Max(
capi.World.BlockAccessor.GetLightLevel(plrPos, EnumLightLevelType.OnlySunLight),
capi.World.BlockAccessor.GetLightLevel(plrPos.Up(), EnumLightLevelType.OnlySunLight)
);
smoothedLightLevel += (lightlevel - smoothedLightLevel) * dt * 4;
// light level > 17 = 100% fog
// light level <= 2 = 0% fog
float fogMultiplier = GameMath.Clamp(smoothedLightLevel / 20f, 0f, 1);
float fac = (float)GameMath.Clamp(capi.World.Player.Entity.Pos.Y / capi.World.SeaLevel, 0, 1);
fac *= fac;
fogMultiplier *= fac;
WeatherDataAtPlayer.BlendedWeatherData.Ambient.FlatFogDensity.Weight *= fogMultiplier;
WeatherDataAtPlayer.BlendedWeatherData.Ambient.FogDensity.Weight *= fogMultiplier;
dt = Math.Min(0.5f, dt);
// Windspeed should be stored inside ClimateConditions and not be a global constant
double windspeed = WeatherDataAtPlayer.GetWindSpeed(plrPosd.Y);
windSpeedSmoothed.X += ((float)windspeed - windSpeedSmoothed.X) * dt;
windRandCounter = (windRandCounter + dt) % (2000 * Math.PI);
double rndx = (2 * Math.Sin(windRandCounter / 8) + Math.Sin(windRandCounter / 2) + Math.Sin(0.5 + 2 * windRandCounter)) / 10.0;
GlobalConstants.CurrentWindSpeedClient.Set(windSpeedSmoothed.X, windSpeedSmoothed.Y, windSpeedSmoothed.Z + (float)rndx * windSpeedSmoothed.X);
capi.Ambient.CurrentModifiers["weather"] = WeatherDataAtPlayer.BlendedWeatherData.Ambient;
}
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (animator == null || renderer == null)
{
return; // not initialized yet
}
if (activeAnimationsByAnimCode.Count > 0 || animator.ActiveAnimationCount > 0)
{
animator.OnFrame(activeAnimationsByAnimCode, deltaTime);
}
if (activeAnimationsByAnimCode.Count == 0 && animator.ActiveAnimationCount == 0 && renderer.ShouldRender && !stopRenderTriggered)
{
stopRenderTriggered = true;
api.World.BlockAccessor.MarkBlockDirty(be.Pos, () => renderer.ShouldRender = false);
}
}
public override void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
if (loadedTexture == null)
{
return;
}
IRenderAPI rpi = api.Render;
Vec3d camPos = api.World.Player.Entity.CameraPos;
if (camPos.SquareDistanceTo(pos.X, pos.Y, pos.Z) > 20 * 20)
{
return;
}
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)
.Translate(0.5f, 0.5f, 0.5f)
.RotateY(rotY + GameMath.PI)
.Translate(-0.5f, -0.5, -0.5f)
.Translate(0.5f, 0.35f, 1 / 16f + 0.03f)
.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 (PercentZoomed == 0)
{
return;
}
IShaderProgram curShader = capi.Render.CurrentActiveShader;
curShader.Stop();
overlayShaderProg.Use();
capi.Render.GlToggleBlend(true);
overlayShaderProg.Uniform("percentZoomed", PercentZoomed);
capi.Render.RenderMesh(quadRef);
overlayShaderProg.Stop();
curShader.Use();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
IShaderProgram curShader = capi.Render.CurrentActiveShader;
Vec4f color = new Vec4f(1, 1, 1, 1);
// Render rectangle
curShader.Uniform("rgbaIn", color);
curShader.Uniform("extraGlow", 0);
curShader.Uniform("applyColor", 0);
curShader.Uniform("tex2d", 0);
curShader.Uniform("noTexture", 1f);
capi.Render.GlPushMatrix();
capi.Render.GlTranslate(10, 10, 50);
capi.Render.GlScale(100, 20, 0);
capi.Render.GlTranslate(0.5f, 0.5f, 0);
capi.Render.GlScale(0.5f, 0.5f, 0);
curShader.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
curShader.UniformMatrix("modelViewMatrix", capi.Render.CurrentModelviewMatrix);
capi.Render.RenderMesh(whiteRectangleRef);
capi.Render.GlPopMatrix();
// Render progress bar
float width = (capi.World.ElapsedMilliseconds / 10f) % 100;
capi.Render.GlPushMatrix();
capi.Render.GlTranslate(10, 10, 50);
capi.Render.GlScale(width, 20, 0);
capi.Render.GlTranslate(0.5f, 0.5f, 0);
capi.Render.GlScale(0.5f, 0.5f, 0);
curShader.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
curShader.UniformMatrix("modelViewMatrix", capi.Render.CurrentModelviewMatrix);
capi.Render.RenderMesh(progressQuadRef);
capi.Render.GlPopMatrix();
}
public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
{
prog.Use();
prog.BindTexture2D("tex", capi.BlockTextureAtlas.Positions[0].atlasTextureId, 0);
prog.Uniform("rgbaFogIn", capi.Render.FogColor);
prog.Uniform("rgbaAmbientIn", capi.Render.AmbientColor);
prog.Uniform("fogMinIn", capi.Render.FogMin);
prog.Uniform("fogDensityIn", capi.Render.FogDensity);
prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
prog.UniformMatrix("modelViewMatrix", capi.Render.CameraMatrixOriginf);
for (int i = 0; i < MechBlockRenderer.Count; i++)
{
MechBlockRenderer[i].OnRenderFrame(deltaTime, prog);
}
prog.Stop();
}
