private void LoadModelMatrix(ItemRenderInfo renderInfo, bool isShadowPass)
{
IRenderAPI rapi = capi.Render;
IEntityPlayer entityPlayer = capi.World.Player.Entity;
Mat4f.Identity(ModelMat);
Mat4f.Translate(ModelMat, ModelMat,
(float)(entityitem.Pos.X - entityPlayer.CameraPos.X),
(float)(entityitem.Pos.Y - entityPlayer.CameraPos.Y),
(float)(entityitem.Pos.Z - entityPlayer.CameraPos.Z)
);
float sizeX = 0.2f * renderInfo.Transform.ScaleXYZ.X;
float sizeY = 0.2f * renderInfo.Transform.ScaleXYZ.Y;
float sizeZ = 0.2f * renderInfo.Transform.ScaleXYZ.Z;
long ellapseMs = capi.World.ElapsedMilliseconds;
if (entity.Collided || entity.Swimming || capi.IsGamePaused)
{
touchGroundMS = ellapseMs;
}
float easeIn = Math.Min(1, (ellapseMs - touchGroundMS) / 200);
float angleMs = Math.Max(ellapseMs - touchGroundMS, 0) * easeIn;
float yangle = angleMs / 7f;
float xangle = angleMs / 7f;
float zangle = angleMs / 7f;
float dx = 0, dz = 0;
if (entity.Swimming)
{
float diff = 1;
if (entityitem.Itemstack.Collectible.MaterialDensity > 1000)
{
dx = GameMath.Sin((float)(ellapseMs / 1000.0)) / 50;
dz = -GameMath.Sin((float)(ellapseMs / 3000.0)) / 50;
diff = 0.1f;
}
xangle = GameMath.Sin((float)(ellapseMs / 1000.0)) * 8 * diff;
yangle = GameMath.Cos((float)(ellapseMs / 2000.0)) * 3 * diff;
zangle = -GameMath.Sin((float)(ellapseMs / 3000.0)) * 8 * diff;
}
Mat4f.Translate(ModelMat, ModelMat, dx + renderInfo.Transform.Translation.X, renderInfo.Transform.Translation.Y, dz + renderInfo.Transform.Translation.Z);
Mat4f.Scale(ModelMat, ModelMat, new float[] { sizeX + scaleRand, sizeY + scaleRand, sizeZ + scaleRand });
Mat4f.RotateY(ModelMat, ModelMat, GameMath.DEG2RAD * (renderInfo.Transform.Rotation.Y + yangle) + (renderInfo.Transform.Rotate ? yRotRand : 0));
Mat4f.RotateZ(ModelMat, ModelMat, GameMath.DEG2RAD * (renderInfo.Transform.Rotation.Z + zangle));
Mat4f.RotateX(ModelMat, ModelMat, GameMath.DEG2RAD * (renderInfo.Transform.Rotation.X + xangle));
Mat4f.Translate(ModelMat, ModelMat, -renderInfo.Transform.Origin.X, -renderInfo.Transform.Origin.Y, -renderInfo.Transform.Origin.Z);
}
public void RenderLiquidItemStackGui(ItemSlot inSlot, ItemRenderInfo renderInfo, Matrixf modelMat, double posX, double posY, double posZ, float size, int color, bool rotate = false, bool showStackSize = true)
{
ItemStack itemstack = inSlot.Itemstack;
WaterTightContainableProps props = BlockLiquidContainerBase.GetContainableProps(itemstack);
capi.Render.RenderMesh(renderInfo.ModelRef);
if (showStackSize)
{
float litreFloat = (float)itemstack.StackSize / props.ItemsPerLitre;
string litres;
if (litreFloat < 0.1)
{
litres = Lang.Get("{0} mL", (int)(litreFloat * 1000));
}
else
{
litres = Lang.Get("{0:0.##} L", litreFloat);
}
float mul = size / (float)GuiElement.scaled(32 * 0.8f);
var texttex = GetOrCreateLitreTexture(litres, size, mul);
capi.Render.GlToggleBlend(true, EnumBlendMode.PremultipliedAlpha);
capi.Render.Render2DLoadedTexture(texttex,
(int)(posX + size + 1 - texttex.Width - GuiElement.scaled(1)),
(int)(posY + size - texttex.Height + mul * GuiElement.scaled(3) - GuiElement.scaled(5)),
(int)posZ + 60
);
capi.Render.GlToggleBlend(true, EnumBlendMode.Standard);
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
if (itemstack.Attributes.GetInt("pieSize") == 1)
{
if (target == EnumItemRenderTarget.Gui)
{
renderinfo.Transform = oneSliceTranformGui;
}
if (target == EnumItemRenderTarget.HandTp)
{
renderinfo.Transform = oneSliceTranformTp;
}
}
renderinfo.ModelRef = ms.GetOrCreatePieMeshRef(itemstack);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
ItemStack[] contents = GetNonEmptyContents(capi.World, itemstack);
string recipeCode = itemstack.Attributes.GetString("recipeCode");
AssetLocation loc = LabelForContents(recipeCode, contents);
if (loc == null)
{
return;
}
Dictionary <string, MeshRef> meshrefs = ObjectCacheUtil.GetOrCreate(capi, "blockcrockGuiMeshRefs", () =>
{
return(new Dictionary <string, MeshRef>());
});
string key = Code.ToShortString() + loc.ToShortString();
MeshRef meshref;
if (!meshrefs.TryGetValue(key, out meshref))
{
MeshData mesh = GenMesh(capi, loc, new Vec3f(0, 270, 0));
//mesh.Rgba2 = null;
meshrefs[key] = meshref = capi.Render.UploadMesh(mesh);
}
renderinfo.ModelRef = meshref;
}
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 override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
MeshRef meshref = meshCache.GetOrCreateMealInContainerMeshRef(this, GetCookingRecipe(capi.World, itemstack), GetNonEmptyContents(capi.World, itemstack));
if (meshref != null)
{
renderinfo.ModelRef = meshref;
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
ChiselBlockModelCache cache = capi.ModLoader.GetModSystem <ChiselBlockModelCache>();
renderinfo.ModelRef = cache.GetOrCreateMeshRef(itemstack);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <string, MeshRef> meshrefs = new Dictionary <string, MeshRef>();
string key = "genericTypedContainerMeshRefs" + FirstCodePart() + SubtypeInventory;
meshrefs = ObjectCacheUtil.GetOrCreate(capi, key, () =>
{
Dictionary <string, MeshData> meshes = GenGuiMeshes(capi);
foreach (var val in meshes)
{
val.Value.Rgba2 = null;
meshrefs[val.Key] = capi.Render.UploadMesh(val.Value);
}
return(meshrefs);
});
string type = itemstack.Attributes.GetString("type", defaultType);
if (!meshrefs.TryGetValue(type, out renderinfo.ModelRef))
{
MeshData mesh = GenGuiMesh(capi, type);
meshrefs[type] = renderinfo.ModelRef = capi.Render.UploadMesh(mesh);
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <int, MeshRef> meshrefs;
object obj;
if (capi.ObjectCache.TryGetValue("cauldMeshRefs", out obj))
{
meshrefs = obj as Dictionary <int, MeshRef>;
}
else
{
capi.ObjectCache["cauldMeshRefs"] = meshrefs = new Dictionary <int, MeshRef>();
}
ItemStack[] contentStacks = GetContents(capi.World, itemstack);
if (contentStacks == null || contentStacks.Length == 0)
{
return;
}
int hashcode = GetCauldHashCode(contentStacks[5], contentStacks[6]);
MeshRef meshRef = null;
if (!meshrefs.TryGetValue(hashcode, out meshRef))
{
MeshData meshdata = GenMesh(contentStacks[5], contentStacks[6]);
meshrefs[hashcode] = meshRef = capi.Render.UploadMesh(meshdata);
}
renderinfo.ModelRef = meshRef;
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <int, MeshRef> meshrefs;
object obj;
if (capi.ObjectCache.TryGetValue("barrelMeshRefs", out obj))
{
meshrefs = obj as Dictionary <int, MeshRef>;
}
else
{
capi.ObjectCache["barrelMeshRefs"] = meshrefs = new Dictionary <int, MeshRef>();
}
ItemStack[] contentStacks = GetContents(capi.World, itemstack);
if (contentStacks == null || contentStacks.Length == 0)
{
return;
}
bool issealed = itemstack.Attributes.GetBool("sealed");
int hashcode = GetBarrelHashCode(contentStacks[0], contentStacks.Length > 1 ? contentStacks[1] : null);
MeshRef meshRef;
if (!meshrefs.TryGetValue(hashcode, out meshRef))
{
MeshData meshdata = GenMesh(contentStacks[0], contentStacks.Length > 1 ? contentStacks[1] : null, issealed);
meshrefs[hashcode] = meshRef = capi.Render.UploadMesh(meshdata);
}
renderinfo.ModelRef = meshRef;
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
int meshrefId = itemstack.Attributes.GetInt("meshRefId");
if (!itemstack.Attributes.HasAttribute("meshRefId"))
{
meshrefId = ++nextMeshRefId;
}
CachedMeshRef cmr = ObjectCacheUtil.GetOrCreate(capi, "" + meshrefId, () =>
{
int textureid;
byte[,,] voxels = GetVoxels(itemstack);
MeshData mesh = GenMesh(capi, itemstack, voxels, out textureid);
return(new CachedMeshRef()
{
meshref = capi.Render.UploadMesh(mesh),
TextureId = textureid
});
});
renderinfo.ModelRef = cmr.meshref;
renderinfo.TextureId = cmr.TextureId;
itemstack.Attributes.SetInt("meshRefId", meshrefId);
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
}
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 override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
Dictionary <string, MeshRef> tapestryMeshes;
tapestryMeshes = ObjectCacheUtil.GetOrCreate(capi, "tapestryMeshesInventory", () => new Dictionary <string, MeshRef>());
renderinfo.NormalShaded = false;
MeshRef meshref;
string type = itemstack.Attributes.GetString("type", "");
if (!tapestryMeshes.TryGetValue(type, out meshref))
{
MeshData mesh = genMesh(false, type, 0, true);
meshref = capi.Render.UploadMesh(mesh);
tapestryMeshes[type] = meshref;
}
renderinfo.ModelRef = meshref;
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <string, MeshRef> meshrefs = new Dictionary <string, MeshRef>();
object obj;
if (capi.ObjectCache.TryGetValue("blockLanternGuiMeshRefs", out obj))
{
meshrefs = obj as Dictionary <string, MeshRef>;
}
else
{
Dictionary <string, MeshData> lanternMeshes = GenGuiMeshes(capi);
foreach (var val in lanternMeshes)
{
meshrefs[val.Key] = capi.Render.UploadMesh(val.Value);
}
capi.ObjectCache["blockLanternGuiMeshRefs"] = meshrefs;
}
string material = itemstack.Attributes.GetString("material");
string lining = itemstack.Attributes.GetString("lining");
meshrefs.TryGetValue(material + "-" + lining, out renderinfo.ModelRef);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
JsonObject attrObj = itemstack.Collectible.Attributes;
if (attrObj?["wearableAttachment"].Exists != true)
{
return;
}
Dictionary <string, MeshRef> armorMeshrefs = ObjectCacheUtil.GetOrCreate(capi, "armorMeshRefs", () => new Dictionary <string, MeshRef>());
string key = "armorModelRef-" + itemstack.Collectible.Code.ToString();
if (!armorMeshrefs.TryGetValue(key, out renderinfo.ModelRef))
{
ITexPositionSource texSource = capi.Tesselator.GetTextureSource(itemstack.Item);
var mesh = genMesh(capi, itemstack, texSource);
renderinfo.ModelRef = armorMeshrefs[key] = mesh == null ? renderinfo.ModelRef : capi.Render.UploadMesh(mesh);
}
}
/// <summary>
/// Called when the collectible is rendered in hands, inventory or on the ground
/// </summary>
/// <param name="capi"></param>
/// <param name="itemstack"></param>
/// <param name="target"></param>
/// <param name="renderinfo"></param>
public virtual void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <string, MeshRef> meshrefs = ObjectCacheUtil.GetOrCreate(capi, "blockLanternGuiMeshRefs", () =>
{
return(new Dictionary <string, MeshRef>());
});
string material = itemstack.Attributes.GetString("material");
string lining = itemstack.Attributes.GetString("lining");
string glass = itemstack.Attributes.GetString("glass", "quartz");
string key = material + "-" + lining + "-" + glass;
MeshRef meshref;
if (!meshrefs.TryGetValue(key, out meshref))
{
AssetLocation shapeloc = Shape.Base.Clone().WithPathPrefix("shapes/").WithPathAppendix(".json");
Shape shape = capi.Assets.TryGet(shapeloc).ToObject <Shape>();
MeshData mesh = GenMesh(capi, material, lining, glass, shape);
//mesh.Rgba2 = null;
meshrefs[key] = meshref = capi.Render.UploadMesh(mesh);
}
renderinfo.ModelRef = meshref;
renderinfo.CullFaces = false;
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
if (itemstack.Attributes.GetOrAddTreeAttribute("toolparts").Count > 0)
{
MeshRef meshRef = MeshManager.GetMesh(api.World as ClientMain, itemstack);
System.Console.WriteLine("MeshRef exists: {0}", meshRef != null);
if (meshRef != null)
{
renderinfo.ModelRef = meshRef;
}
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
/*if (itemstack.Attributes.HasAttribute("hashCode"))
* {
* int hashcode = itemstack.Attributes.GetInt("hashCode");
*
* renderinfo.ModelRef = ObjectCacheUtil.GetOrCreate(capi, "ironbloom-" + hashcode, () =>
* {
* MeshData mesh = GenMesh(capi, itemstack);
* return capi.Render.UploadMesh(mesh);
* });
* }*/
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <string, MeshRef> meshrefs = new Dictionary <string, MeshRef>();
object obj;
if (capi.ObjectCache.TryGetValue("genericTypedContainerMeshRefs" + FirstCodePart(), out obj))
{
meshrefs = obj as Dictionary <string, MeshRef>;
}
else
{
Dictionary <string, MeshData> meshes = GenGuiMeshes(capi);
foreach (var val in meshes)
{
meshrefs[val.Key] = capi.Render.UploadMesh(val.Value);
}
capi.ObjectCache["genericTypedContainerMeshRefs" + FirstCodePart()] = meshrefs;
}
string type = itemstack.Attributes.GetString("type", defaultType);
meshrefs.TryGetValue(type, out renderinfo.ModelRef);
}
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 override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
string blockMaterialCode = GetBlockMaterialCode(itemstack);
if (blockMaterialCode == null)
{
return;
}
string key = "pan-filled-" + blockMaterialCode;
renderinfo.ModelRef = ObjectCacheUtil.GetOrCreate <MeshRef>(capi, key, () =>
{
AssetLocation shapeloc = new AssetLocation("shapes/block/wood/pan/filled.json");
Shape shape = capi.Assets.TryGet(shapeloc).ToObject <Shape>();
MeshData meshdata;
Block block = capi.World.GetBlock(new AssetLocation(blockMaterialCode));
AtlasSize = capi.BlockTextureAtlas.Size;
matTexPosition = capi.BlockTextureAtlas.GetPosition(block, "up");
ownTextureSource = capi.Tesselator.GetTexSource(this);
capi.Tesselator.TesselateShape("filledpan", shape, out meshdata, this);
return(capi.Render.UploadMesh(meshdata));
});
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
if (meshCache == null)
{
meshCache = capi.ModLoader.GetModSystem <MealMeshCache>();
}
MeshRef meshref = meshCache.GetOrCreateMealMeshRef(this, this.Shape, GetCookingRecipe(capi.World, itemstack), GetContents(capi.World, itemstack));
if (meshref != null)
{
renderinfo.ModelRef = meshref;
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
if (meshCache == null)
{
meshCache = capi.ModLoader.GetModSystem <MealMeshCache>();
}
CookingRecipe recipe = GetCookingRecipe(capi.World, itemstack);
ItemStack[] contents = GetContents(capi.World, itemstack);
float yoff = 2.5f; // itemstack.Attributes.GetInt("servings");
MeshRef meshref = meshCache.GetOrCreateMealMeshRef(this.Shape, recipe, contents, new Vec3f(0, yoff / 16f, 0));
if (meshref != null)
{
renderinfo.ModelRef = meshref;
}
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
if (itemstack.Collectible.Variant["type"] == "cutting")
{
curTreeType = itemstack.Attributes.GetString("type");
var dict = ObjectCacheUtil.GetOrCreate(capi, "cuttingMeshRefs", () => new Dictionary <string, MeshRef>());
if (!dict.TryGetValue(curTreeType, out var meshref))
{
curTessShape = capi.TesselatorManager.GetCachedShape(this.Shape.Base);
capi.Tesselator.TesselateShape("fruittreecutting", curTessShape, out var meshdata, this);
dict[curTreeType] = renderinfo.ModelRef = capi.Render.UploadMesh(meshdata);
}
else
{
renderinfo.ModelRef = meshref;
}
}
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
if (target == EnumItemRenderTarget.HandFp)
{
bool sneak = capi.World.Player.Entity.Controls.Sneak;
curOffY += ((sneak ? 0.4f : offY) - curOffY) * renderinfo.dt * 8;
renderinfo.Transform.Translation.X = curOffY;
renderinfo.Transform.Translation.Y = curOffY * 1.2f;
renderinfo.Transform.Translation.Z = curOffY * 1.2f;
}
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
Dictionary <int, MeshRef> meshrefs = null;
object obj;
if (capi.ObjectCache.TryGetValue("bucketMeshRefs", out obj))
{
meshrefs = obj as Dictionary <int, MeshRef>;
}
else
{
capi.ObjectCache["bucketMeshRefs"] = meshrefs = new Dictionary <int, MeshRef>();
}
ItemStack contentStack = GetContent(capi.World, itemstack);
if (contentStack == null)
{
return;
}
int hashcode = GetBucketHashCode(capi.World, contentStack);
MeshRef meshRef = null;
if (!meshrefs.TryGetValue(hashcode, out meshRef))
{
MeshData meshdata = GenMesh(capi, contentStack);
//meshdata.Rgba2 = null;
meshrefs[hashcode] = meshRef = capi.Render.UploadMesh(meshdata);
}
renderinfo.ModelRef = meshRef;
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
EnumSlabPlaceMode mode = (EnumSlabPlaceMode)itemstack.Attributes.GetInt("slabPlaceMode", 0);
if (mode == EnumSlabPlaceMode.Vertical)
{
renderinfo.Transform = renderinfo.Transform.Clone();
renderinfo.Transform.Rotation.X = -80;
renderinfo.Transform.Rotation.Y = 0;
renderinfo.Transform.Rotation.Z = -22.5f;
}
if (mode == EnumSlabPlaceMode.Horizontal)
{
renderinfo.Transform = renderinfo.Transform.Clone();
renderinfo.Transform.Rotation.X = 5;
}
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
}
public override void OnBeforeRender(ICoreClientAPI capi, ItemStack itemstack, EnumItemRenderTarget target, ref ItemRenderInfo renderinfo)
{
base.OnBeforeRender(capi, itemstack, target, ref renderinfo);
if (isMapleSeed && target == EnumItemRenderTarget.Ground)
{
EntityItem ei = (renderinfo.InSlot as EntityItemSlot).Ei;
if (!ei.Collided && !ei.Swimming)
{
renderinfo.Transform = renderinfo.Transform.Clone(); // dont override the original transform
renderinfo.Transform.Rotation.X = -90;
renderinfo.Transform.Rotation.Y = (float)(capi.World.ElapsedMilliseconds % 360.0) * 2f;
renderinfo.Transform.Rotation.Z = 0;
}
}
}
