Exemplo n.º 1
0
        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();
        }
Exemplo n.º 2
0
        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();
        }
Exemplo n.º 3
0
        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);*/
        }
Exemplo n.º 4
0
        private void RenderRecipeOutLine()
        {
            if (recipeOutlineMeshRef == null || api.HideGuis)
            {
                return;
            }
            IRenderAPI           rpi         = api.Render;
            IClientWorldAccessor worldAccess = api.World;
            EntityPos            plrPos      = worldAccess.Player.Entity.Pos;
            Vec3d camPos = worldAccess.Player.Entity.CameraPos;

            ModelMat.Set(rpi.CameraMatrixOriginf).Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z);
            outLineColorMul.A = 1 - GameMath.Clamp((float)Math.Sqrt(plrPos.SquareDistanceTo(pos.X, pos.Y, pos.Z)) / 5 - 1f, 0, 1);

            rpi.LineWidth = 2;
            rpi.GLEnableDepthTest();
            rpi.GlToggleBlend(true);

            IShaderProgram prog = rpi.GetEngineShader(EnumShaderProgram.Wireframe);

            prog.Use();
            prog.UniformMatrix("projectionMatrix", rpi.CurrentProjectionMatrix);
            prog.UniformMatrix("modelViewMatrix", ModelMat.Values);
            prog.Uniform("colorIn", outLineColorMul);
            rpi.RenderMesh(recipeOutlineMeshRef);
            prog.Stop();
        }
Exemplo n.º 5
0
        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();
        }
Exemplo n.º 6
0
        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();
        }
Exemplo n.º 7
0
        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);
            }
        }
Exemplo n.º 8
0
        public void CustomRender(float dt)
        {
            if (LineDebug && capi != null)
            {
                BlockPos originPos = CenterPosition.AsBlockPos;

                for (int i = 0; i < Constraints.Count; i++)
                {
                    ClothPoint p1 = Constraints[i].Point1;
                    ClothPoint p2 = Constraints[i].Point2;

                    debugUpdateMesh.xyz[i * 6 + 0] = (float)(p1.Pos.X - originPos.X);
                    debugUpdateMesh.xyz[i * 6 + 1] = (float)(p1.Pos.Y - originPos.Y) + 0.005f;
                    debugUpdateMesh.xyz[i * 6 + 2] = (float)(p1.Pos.Z - originPos.Z);

                    debugUpdateMesh.xyz[i * 6 + 3] = (float)(p2.Pos.X - originPos.X);
                    debugUpdateMesh.xyz[i * 6 + 4] = (float)(p2.Pos.Y - originPos.Y) + 0.005f;
                    debugUpdateMesh.xyz[i * 6 + 5] = (float)(p2.Pos.Z - originPos.Z);
                }


                capi.Render.UpdateMesh(debugMeshRef, debugUpdateMesh);

                IShaderProgram prog = capi.Shader.GetProgram((int)EnumShaderProgram.Autocamera);
                prog.Use();

                capi.Render.LineWidth = 6;
                capi.Render.BindTexture2d(0);

                capi.Render.GLDisableDepthTest();

                Vec3d cameraPos = capi.World.Player.Entity.CameraPos;

                mat.Set(capi.Render.CameraMatrixOrigin);
                mat.Translate(
                    (float)(originPos.X - cameraPos.X),
                    (float)(originPos.Y - cameraPos.Y),
                    (float)(originPos.Z - cameraPos.Z)
                    );

                prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);
                prog.UniformMatrix("modelViewMatrix", mat.Values);

                capi.Render.RenderMesh(debugMeshRef);

                prog.Stop();


                capi.Render.GLEnableDepthTest();
            }
        }
        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 (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)
        {
            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();
        }
Exemplo n.º 12
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (prog.Disposed)
            {
                return;
            }
            IShaderProgram curShader = capi.Render.CurrentActiveShader;

            curShader.Stop();

            prog.Use();
            capi.Render.GlToggleBlend(true);
            prog.SetDefaultUniforms(capi);
            prog.BindTexture2D("iColor", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].ColorTextureIds[0], 0);

            capi.Render.RenderMesh(quadRef);
            prog.Stop();
            curShader.Use();
        }
Exemplo n.º 13
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (prog?.Disposed ?? true)
            {
                return;
            }
            capi.Render.GlToggleBlend(true);
            IShaderProgram curShader = capi.Render.CurrentActiveShader;

            curShader?.Stop();

            prog.Use();
            prog.Uniform("iTime", capi.World.ElapsedMilliseconds / 500f);
            prog.Uniform("iResolution", new Vec2f(capi.Render.FrameWidth, capi.Render.FrameHeight));
            prog.Uniform("iProgressBar", capi.ModLoader.GetModSystem <InWorldCraftingSystem>().progress);
            capi.Render.RenderMesh(quadRef);
            prog.Stop();

            curShader?.Use();
        }
Exemplo n.º 14
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            ItemStack stack = capi.World.Player.InventoryManager.ActiveHotbarSlot.Itemstack;

            if (stack == null || !stack.Collectible.Code.Path.Contains("chick"))
            {
                return;
            }

            IShaderProgram curShader = capi.Render.CurrentActiveShader;

            curShader.Stop();

            overlayShaderProg.Use();

            capi.Render.GlToggleBlend(true);
            overlayShaderProg.Uniform("time", capi.World.ElapsedMilliseconds / 1000f);

            capi.Render.RenderMesh(quadRef);
            overlayShaderProg.Stop();


            curShader.Use();
        }
Exemplo n.º 15
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (prog.Disposed)
            {
                return;
            }

            BlockPos       Pos       = capi.World.Player.Entity.Pos.AsBlockPos;
            IShaderProgram curShader = capi.Render.CurrentActiveShader;

            curShader.Stop();

            prog.Use();

            capi.Render.GlToggleBlend(true);
            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);

            capi.Render.RenderMesh(quadRef);
            prog.Stop();
            curShader.Use();
        }
        public void OnRenderFrame(float dt, EnumRenderStage stage)
        {
            if (!ShouldRender)
            {
                return;
            }

            bool shadowPass = stage != EnumRenderStage.Opaque;

            EntityPlayer entityPlayer = capi.World.Player.Entity;

            Mat4f.Identity(ModelMat);
            Mat4f.Translate(ModelMat, ModelMat, (float)(pos.X - entityPlayer.CameraPos.X), (float)(pos.Y - entityPlayer.CameraPos.Y), (float)(pos.Z - entityPlayer.CameraPos.Z));

            Mat4f.Translate(ModelMat, ModelMat, 0.5f, 0, 0.5f);
            Mat4f.RotateY(ModelMat, ModelMat, rotation.Y * GameMath.DEG2RAD);
            Mat4f.Translate(ModelMat, ModelMat, -0.5f, 0, -0.5f);

            IRenderAPI rpi = capi.Render;


            IShaderProgram prevProg = rpi.CurrentActiveShader;

            prevProg?.Stop();


            IShaderProgram prog = rpi.GetEngineShader(shadowPass ? EnumShaderProgram.Shadowmapentityanimated : EnumShaderProgram.Entityanimated);

            prog.Use();
            Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs((int)pos.X, (int)pos.Y, (int)pos.Z);

            rpi.GlToggleBlend(true, EnumBlendMode.Standard);

            if (!shadowPass)
            {
                prog.Uniform("rgbaAmbientIn", rpi.AmbientColor);
                prog.Uniform("rgbaFogIn", rpi.FogColor);
                prog.Uniform("fogMinIn", rpi.FogMin);
                prog.Uniform("fogDensityIn", rpi.FogDensity);
                prog.Uniform("rgbaLightIn", lightrgbs);
                prog.Uniform("renderColor", ColorUtil.WhiteArgbVec);
                prog.Uniform("alphaTest", 0.1f);
                prog.UniformMatrix("modelMatrix", ModelMat);
                prog.UniformMatrix("viewMatrix", rpi.CameraMatrixOriginf);
                prog.Uniform("windWaveIntensity", (float)0);
                prog.Uniform("skipRenderJointId", -2);
                prog.Uniform("skipRenderJointId2", -2);
                prog.Uniform("glitchEffectStrength", 0f);
            }
            else
            {
                prog.UniformMatrix("modelViewMatrix", Mat4f.Mul(new float[16], capi.Render.CurrentModelviewMatrix, ModelMat));
            }

            prog.BindTexture2D("entityTex", textureId, 0);
            prog.UniformMatrix("projectionMatrix", rpi.CurrentProjectionMatrix);

            prog.Uniform("addRenderFlags", 0);


            prog.UniformMatrices(
                "elementTransforms",
                GlobalConstants.MaxAnimatedElements,
                animator.Matrices
                );

            capi.Render.RenderMesh(meshref);

            prog.Stop();
            prevProg?.Use();
        }
        public void OnRenderFrame(float dt, EnumRenderStage stage)
        {
            if (stage == EnumRenderStage.Opaque)
            {
                prog.Use();
                prog.UniformMatrix("projection", capi.Render.CurrentProjectionMatrix);
                prog.UniformMatrix("view", capi.Render.CameraMatrixOriginf);

                for (int i = 0; i < lightningFlashes.Count; i++)
                {
                    var lflash = lightningFlashes[i];
                    lflash.Render(dt);

                    if (!lflash.Alive)
                    {
                        lflash.Dispose();
                        lightningFlashes.RemoveAt(i);
                        i--;
                    }
                }

                prog.Stop();
                return;
            }

            if (stage == EnumRenderStage.Done)
            {
                AmbientModifier sunGlowAmb = capi.Ambient.CurrentModifiers["sunglow"];
                actualSunGlowAmb.FogColor.Weight = sunGlowAmb.FogColor.Weight;

                dt = Math.Min(0.5f, dt);

                if (nearLightningCoolDown > 0)
                {
                    nearLightningCoolDown -= dt;
                }

                return;
            }

            if (lightningTime > 0)
            {
                float mul = Math.Min(10 * lightningIntensity * lightningTime, 1.5f);

                WeatherDataSnapshot weatherData = weatherSysc.BlendedWeatherData;

                LightningAmbient.CloudBrightness.Value = Math.Max(weatherData.Ambient.SceneBrightness.Value, mul);
                LightningAmbient.FogBrightness.Value   = Math.Max(weatherData.Ambient.FogBrightness.Value, mul);

                LightningAmbient.CloudBrightness.Weight = Math.Min(1, mul);
                LightningAmbient.FogBrightness.Weight   = Math.Min(1, mul);

                float sceneBrightIncrease = GameMath.Min(mul, GameMath.Max(0, lightningIntensity - 0.75f));

                if (sceneBrightIncrease > 0)
                {
                    LightningAmbient.SceneBrightness.Weight = Math.Min(1, sceneBrightIncrease);
                    LightningAmbient.SceneBrightness.Value  = 1;

                    AmbientModifier sunGlowAmb = capi.Ambient.CurrentModifiers["sunglow"];

                    float nowWeight = GameMath.Clamp(1 - sceneBrightIncrease, 0, 1);

                    sunGlowAmb.FogColor.Weight     = Math.Min(sunGlowAmb.FogColor.Weight, nowWeight);
                    sunGlowAmb.AmbientColor.Weight = Math.Min(sunGlowAmb.AmbientColor.Weight, nowWeight);
                }


                lightningTime -= dt / 1.7f;

                if (lightningTime <= 0)
                {
                    // Restore previous values
                    AmbientModifier sunGlowAmb = capi.Ambient.CurrentModifiers["sunglow"];
                    sunGlowAmb.FogColor.Weight     = actualSunGlowAmb.FogColor.Weight;
                    sunGlowAmb.AmbientColor.Weight = actualSunGlowAmb.AmbientColor.Weight;

                    LightningAmbient.CloudBrightness.Weight = 0;
                    LightningAmbient.FogBrightness.Weight   = 0;
                    LightningAmbient.SceneBrightness.Weight = 0;
                }
            }
        }
Exemplo n.º 18
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (!renderClouds)
            {
                return;
            }

            if (!capi.IsGamePaused)
            {
                CloudTick(deltaTime);
            }

            if (capi.Render.FrameWidth == 0)
            {
                return;
            }

            prog.Use();
            prog.Uniform("sunPosition", capi.World.Calendar.SunPositionNormalized);


            double plrPosX = capi.World.Player.Entity.Pos.X;
            double plrPosZ = capi.World.Player.Entity.Pos.Z;

            double offsetX = committedState.CenterTilePos.X * CloudTileSize - plrPosX + windOffsetX;
            double offsetZ = committedState.CenterTilePos.Z * CloudTileSize - plrPosZ + windOffsetZ;


            prog.Uniform("sunColor", capi.World.Calendar.SunColor);
            prog.Uniform("dayLight", Math.Max(0, capi.World.Calendar.DayLightStrength - capi.World.Calendar.MoonLightStrength * 0.95f));
            prog.Uniform("windOffset", new Vec3f((float)offsetX, 0, (float)offsetZ));



            prog.Uniform("rgbaFogIn", capi.Ambient.BlendedFogColor);
            prog.Uniform("fogMinIn", capi.Ambient.BlendedFogMin);
            prog.Uniform("fogDensityIn", capi.Ambient.BlendedFogDensity);
            prog.Uniform("playerPos", capi.Render.ShaderUniforms.PlayerPos);
            prog.Uniform("tileOffset", new Vec2f((committedState.CenterTilePos.X - committedState.TileOffsetX) * CloudTileSize, (committedState.CenterTilePos.Z - committedState.TileOffsetZ) * CloudTileSize));

            prog.Uniform("cloudTileSize", CloudTileSize);
            prog.Uniform("cloudsLength", (float)CloudTileSize * CloudTileLength);

            prog.Uniform("globalCloudBrightness", blendedGlobalCloudBrightness);

            float yTranslate = (float)(weatherSys.CloudsYPosition * capi.World.BlockAccessor.MapSizeY + 0.5 - capi.World.Player.Entity.CameraPos.Y);

            prog.Uniform("cloudYTranslate", yTranslate);
            prog.Uniform("cloudCounter", (float)((capi.World.Calendar.TotalHours * 20) % 578f));

            prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);

            //int cnt = capi.Render.PointLightsCount;
            //prog.Uniform("pointLightQuantity", cnt);
            //shv.PointLightsArray(cnt, ScreenManager.Platform.PointLights3);
            //shv.PointLightColorsArray(cnt, ScreenManager.Platform.PointLightColors3);

            prog.Uniform("flatFogDensity", capi.Ambient.BlendedFlatFogDensity);
            prog.Uniform("flatFogStart", capi.Ambient.BlendedFlatFogYPosForShader);


            mvMat
            .Set(capi.Render.MvMatrix.Top)
            .FollowPlayer()
            .Translate(offsetX, yTranslate, offsetZ)
            ;


            prog.UniformMatrix("modelViewMatrix", mvMat.Values);
            capi.Render.RenderMeshInstanced(cloudTilesMeshRef, QuantityCloudTiles);


            // Very slightly rotate all the clouds so it looks better when they pass through blocks
            // Putting this line before translate = Clouds no longer centered around the player
            // Putting it after the translate = Clouds hop by a few pixels on every reload
            // Need to find a correct solution for this
            // Mat4.Rotate(mv, mv, 0.04f, new float[] { 0, 1, 0 });

            prog.Stop();
        }
Exemplo n.º 19
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (fallTime < -1)
            {
                capi.Event.UnregisterRenderer(this, stage);
                Dispose();
                return;
            }

            float percent = fallTime / startFallTime;

            IRenderAPI rpi    = capi.Render;
            Vec3d      camPos = capi.World.Player.Entity.CameraPos;

            if (isLeaves)
            {
                rpi.GlDisableCullFace();
            }

            rpi.GlToggleBlend(true);

            bool shadowPass = stage != EnumRenderStage.Opaque;

            IShaderProgram prevProg = rpi.CurrentActiveShader;

            prevProg?.Stop();

            IShaderProgram sProg = shadowPass ? rpi.GetEngineShader(EnumShaderProgram.Shadowmapentityanimated) : rpi.PreparedStandardShader(pos.X, pos.Y, pos.Z);

            var mat = ModelMat
                      .Identity()
                      .Translate(pos.X - camPos.X, pos.Y - camPos.Y, pos.Z - camPos.Z)
            ;

            switch (fallDirection.Code)
            {
            case "north":
                mat.RotateXDeg(GameMath.Max(percent * 90.0f - 90.0f, -90.0f));
                break;

            case "south":
                mat.Translate(0, 0, 1);
                mat.RotateXDeg(GameMath.Min(percent * -90.0f + 90.0f, 90.0f));
                mat.Translate(0, 0, -1);
                break;

            case "east":
                mat.Translate(1, 0, 1);
                mat.RotateZDeg(GameMath.Max(percent * 90.0f - 90.0f, -90.0f));
                mat.Translate(-1, 0, -1);
                break;

            case "west":
                mat.Translate(0, 0, 1);
                mat.RotateZDeg(GameMath.Min(percent * -90.0f + 90.0f, 90.0f));
                mat.Translate(0, 0, -1);
                break;

            default:
                break;
            }

            var matVals = mat.Values;

            if (!shadowPass)
            {
                var prog = (IStandardShaderProgram)sProg;

                prog.Tex2D       = capi.BlockTextureAtlas.AtlasTextureIds[0];
                prog.ModelMatrix = matVals;

                prog.AlphaTest = 0.4f;

                prog.ViewMatrix       = rpi.CameraMatrixOriginf;
                prog.ProjectionMatrix = rpi.CurrentProjectionMatrix;
                if (fallTime < 0)
                {
                    prog.RgbaTint = new Vec4f(1, 1, 1, 1.0f - Math.Abs(fallTime));
                }
            }
            else
            {
                sProg.Use();
                sProg.BindTexture2D("entityTex", capi.BlockTextureAtlas.AtlasTextureIds[0], 1);
                sProg.UniformMatrix("projectionMatrix", rpi.CurrentProjectionMatrix);
                sProg.UniformMatrix("modelViewMatrix", Mat4f.Mul(new float[16], capi.Render.CurrentModelviewMatrix, matVals));
            }

            rpi.RenderMesh(treeMesh);
            sProg.Stop();

            prevProg?.Use();

            fallTime -= deltaTime;
        }
Exemplo n.º 20
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            if (!renderAurora)
            {
                return;
            }

            if (capi.Render.FrameWidth == 0)
            {
                return;
            }



            quarterSecAccum += deltaTime;
            if (quarterSecAccum > 0.25f)
            {
                plrPos.X = (int)capi.World.Player.Entity.CameraPos.X;
                plrPos.Y = capi.World.SeaLevel;
                plrPos.Z = (int)capi.World.Player.Entity.CameraPos.Z;

                clientClimateCond = capi.World.BlockAccessor.GetClimateAt(plrPos);
                quarterSecAccum   = 0;
            }

            if (clientClimateCond == null)
            {
                return;
            }

            float tempfac = GameMath.Clamp((Math.Max(0, -clientClimateCond.Temperature) - 5) / 15f, 0, 1);

            col.W = GameMath.Clamp(1 - 1.5f * capi.World.Calendar.DayLightStrength, 0, 1) * tempfac;

            if (col.W <= 0)
            {
                return;
            }

            prog.Use();
            prog.Uniform("color", col);
            prog.Uniform("rgbaFogIn", capi.Ambient.BlendedFogColor);
            prog.Uniform("fogMinIn", capi.Ambient.BlendedFogMin);
            prog.Uniform("fogDensityIn", capi.Ambient.BlendedFogDensity);
            prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);

            prog.Uniform("flatFogDensity", capi.Ambient.BlendedFlatFogDensity);
            prog.Uniform("flatFogStart", capi.Ambient.BlendedFlatFogYPosForShader);

            float speedmul = capi.World.Calendar.SpeedOfTime / 60f;

            prog.Uniform("auroraCounter", (float)(capi.InWorldEllapsedMilliseconds / 4000.0 * speedmul) % 579f);


            mvMat
            .Set(capi.Render.MvMatrix.Top)
            .FollowPlayer()
            .Translate(
                0, //    capi.World.BlockAccessor.MapSizeX/2,
                (1.1f * capi.World.BlockAccessor.MapSizeY + 0.5 - capi.World.Player.Entity.CameraPos.Y),
                0  //   capi.World.BlockAccessor.MapSizeZ/2
                )
            ;

            prog.UniformMatrix("modelViewMatrix", mvMat.Values);
            capi.Render.RenderMesh(quadTilesRef);

            prog.Stop();
        }
Exemplo n.º 21
0
        public void OnRenderFrame(float dt, EnumRenderStage stage)
        {
            if (!ShouldRender)
            {
                return;
            }

            animator.OnFrame(activeAnimationsByAnimCode, dt);

            EntityPlayer entityPlayer = capi.World.Player.Entity;

            Mat4f.Identity(ModelMat);
            Mat4f.Translate(ModelMat, ModelMat, (float)(pos.X - entityPlayer.CameraPos.X), (float)(pos.Y - entityPlayer.CameraPos.Y), (float)(pos.Z - entityPlayer.CameraPos.Z));

            Mat4f.Translate(ModelMat, ModelMat, 0.5f, 0, 0.5f);
            Mat4f.RotateY(ModelMat, ModelMat, rotation.Y * GameMath.DEG2RAD);
            Mat4f.Translate(ModelMat, ModelMat, -0.5f, 0, -0.5f);

            IRenderAPI rpi = capi.Render;


            IShaderProgram prevProg = rpi.CurrentActiveShader;

            prevProg?.Stop();


            IShaderProgram prog = rpi.GetEngineShader(EnumShaderProgram.Entityanimated);

            prog.Use();

            prog.Uniform("rgbaAmbientIn", rpi.AmbientColor);
            prog.Uniform("rgbaFogIn", rpi.FogColor);
            prog.Uniform("fogMinIn", rpi.FogMin);
            prog.Uniform("fogDensityIn", rpi.FogDensity);
            prog.BindTexture2D("entityTex", textureId, 0);
            prog.Uniform("alphaTest", 0.1f);
            prog.UniformMatrix("projectionMatrix", rpi.CurrentProjectionMatrix);


            rpi.GlToggleBlend(true, EnumBlendMode.Standard);


            Vec4f lightrgbs = capi.World.BlockAccessor.GetLightRGBs((int)pos.X, (int)pos.Y, (int)pos.Z);

            prog.Uniform("rgbaLightIn", lightrgbs);
            //prog.Uniform("extraGlow", entity.Properties.Client.GlowLevel);
            prog.UniformMatrix("modelMatrix", ModelMat);
            prog.UniformMatrix("viewMatrix", rpi.CameraMatrixOriginf);
            prog.Uniform("addRenderFlags", 0);
            prog.Uniform("windWaveIntensity", (float)0);

            /*color[0] = (entity.RenderColor >> 16 & 0xff) / 255f;
             * color[1] = ((entity.RenderColor >> 8) & 0xff) / 255f;
             * color[2] = ((entity.RenderColor >> 0) & 0xff) / 255f;
             * color[3] = ((entity.RenderColor >> 24) & 0xff) / 255f;
             *
             * prog.Uniform("renderColor", color);*/

            prog.Uniform("renderColor", ColorUtil.WhiteArgbVec);


            prog.UniformMatrices(
                "elementTransforms",
                GlobalConstants.MaxAnimatedElements,
                animator.Matrices
                );

            capi.Render.RenderMesh(meshref);

            prog.Stop();
            prevProg?.Use();
        }
Exemplo n.º 22
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            var plrPos = capi.World.Player.Entity.Pos;
            var bh     = capi.World.Player.Entity.GetBehavior <EntityBehaviorTemporalStabilityAffected>();

            if (bh != null)
            {
                bh.stabilityOffset = 0;
            }

            if (modsys.nearestRifts.Length > 0)
            {
                Rift rift = modsys.nearestRifts[0];

                float dist   = Math.Max(0, GameMath.Sqrt(plrPos.SquareDistanceTo(rift.Position)) - 1 - rift.Size / 2f);
                float f      = Math.Max(0, 1 - dist / 3f);
                float jitter = capi.World.Rand.NextDouble() < 0.25 ? f * ((float)capi.World.Rand.NextDouble() - 0.5f) / 1f : 0;

                GlobalConstants.GuiGearRotJitter = jitter;

                capi.ModLoader.GetModSystem <SystemTemporalStability>().modGlitchStrength = Math.Min(1, f * 1.3f);

                if (bh != null)
                {
                    bh.stabilityOffset = -Math.Pow(Math.Max(0, 1 - dist / 3), 2) * 20;
                }
            }
            else
            {
                capi.ModLoader.GetModSystem <SystemTemporalStability>().modGlitchStrength = 0;
            }

            counter += deltaTime;
            if (capi.World.Rand.NextDouble() < 0.012)
            {
                counter += 20 * (float)capi.World.Rand.NextDouble();
            }

            capi.Render.GLDepthMask(false);

            prog.Use();
            prog.BindTexture2D("primaryFb", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].ColorTextureIds[0], 0);
            prog.BindTexture2D("depthTex", capi.Render.FrameBuffers[(int)EnumFrameBuffer.Primary].DepthTextureId, 1);
            prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);


            int width  = capi.Render.FrameWidth;
            int height = capi.Render.FrameHeight;

            prog.Uniform("counter", counter);
            float bf = 200 + (float)GameMath.Sin(capi.InWorldEllapsedMilliseconds / 24000.0) * 100;

            prog.Uniform("counterSmooth", bf);
            prog.Uniform("invFrameSize", new Vec2f(1f / width, 1f / height));
            int riftIndex = 0;

            cnt = (cnt + 1) % 3;

            foreach (var rift in rifts)
            {
                if (cnt == 0)
                {
                    rift.Visible = capi.World.BlockAccessor.GetChunkAtBlockPos((int)rift.Position.X, (int)rift.Position.Y, (int)rift.Position.Z) != null;
                }

                riftIndex++;
                matrixf.Identity();

                float dx = (float)(rift.Position.X - plrPos.X);
                float dy = (float)(rift.Position.Y - plrPos.Y);
                float dz = (float)(rift.Position.Z - plrPos.Z);

                matrixf.Translate(dx, dy, dz);
                matrixf.ReverseMul(capi.Render.CameraMatrixOriginf);

                matrixf.Values[0] = 1f;
                matrixf.Values[1] = 0f;
                matrixf.Values[2] = 0f;

                //matrixf.Values[4] = 0f;
                //matrixf.Values[5] = 1f;
                //matrixf.Values[6] = 0f;

                matrixf.Values[8]  = 0f;
                matrixf.Values[9]  = 0f;
                matrixf.Values[10] = 1f;

                float size = rift.GetNowSize(capi);
                matrixf.Scale(size, size, size);

                prog.UniformMatrix("modelViewMatrix", matrixf.Values);
                prog.Uniform("riftIndex", riftIndex);

                capi.Render.RenderMesh(meshref);

                if (dx * dx + dy * dy + dz * dz < 40 * 40)
                {
                    Vec3d ppos = rift.Position;
                    capi.World.SpawnParticles(0.1f, ColorUtil.ColorFromRgba(21 / 2, 70 / 2, 116 / 2, 128), ppos, ppos, new Vec3f(-0.125f, -0.125f, -0.125f), new Vec3f(0.125f, 0.125f, 0.125f), 5, 0, (0.125f / 2 + (float)capi.World.Rand.NextDouble() * 0.25f) / 2);
                }
            }


            counter = GameMath.Mod(counter + deltaTime, GameMath.TWOPI * 100f);

            prog.Stop();

            capi.Render.GLDepthMask(true);
        }
Exemplo n.º 23
0
        public void OnRenderFrame(float deltaTime, EnumRenderStage stage)
        {
            capi.Render.GlMatrixModeModelView();

            if (!renderClouds || capi.Render.FrameWidth == 0)
            {
                return;
            }



            prog.Use();
            prog.Uniform("sunPosition", capi.World.Calendar.SunPositionNormalized);

            int[] hsv = ColorUtil.RgbToHsvInts((int)(capi.World.Calendar.SunColor.R * 255), (int)(capi.World.Calendar.SunColor.G * 255), (int)(capi.World.Calendar.SunColor.B * 255));
            hsv[1] = (int)(hsv[1] * 0.9);
            hsv[2] = (int)(hsv[2] * 0.9);
            int[] rgba   = ColorUtil.Hsv2RgbInts(hsv[0], hsv[1], hsv[2]);
            Vec3f sunCol = new Vec3f(rgba[0] / 255f, rgba[1] / 255f, rgba[2] / 255f);

            prog.Uniform("sunColor", sunCol);
            prog.Uniform("dayLight", Math.Max(0, capi.World.Calendar.DayLightStrength + capi.World.Calendar.MoonLightStrength - 0.15f));
            prog.Uniform("windOffset", new Vec3f(
                             (float)(GameMath.Mod((float)capi.World.Player.Entity.Pos.X, CloudTileSize)),
                             0,
                             (float)(GameMath.Mod((float)capi.World.Player.Entity.Pos.Z, CloudTileSize))
                             ));
            prog.Uniform("globalCloudBrightness", blendedGlobalCloudBrightness);
            prog.Uniform("rgbaFogIn", capi.Ambient.BlendedFogColor);
            prog.Uniform("fogMinIn", capi.Ambient.BlendedFogMin);
            prog.Uniform("fogDensityIn", capi.Ambient.BlendedFogDensity);
            prog.Uniform("playerPos", capi.World.Player.Entity.Pos.XYZFloat);

            prog.Uniform("cloudTileSize", CloudTileSize);
            prog.Uniform("cloudsLength", (float)CloudTileSize * CloudTileLength);

            prog.UniformMatrix("projectionMatrix", capi.Render.CurrentProjectionMatrix);

            //int cnt = capi.Render.PointLightsCount;
            //prog.Uniform("pointLightQuantity", cnt);
            //shv.PointLightsArray(cnt, ScreenManager.Platform.PointLights3);
            //shv.PointLightColorsArray(cnt, ScreenManager.Platform.PointLightColors3);

            prog.Uniform("flatFogDensity", capi.Ambient.BlendedFlatFogDensity);
            prog.Uniform("flatFogStart", capi.Ambient.BlendedFlatFogYPosForShader);



            capi.Render.GlPushMatrix();
            {
                double[] mvMatd = capi.Render.MvMatrix.Top;
                mvMatd[12] = 0;
                mvMatd[13] = 0;
                mvMatd[14] = 0;

                double partialTileOffsetX = capi.World.Player.Entity.Pos.X % CloudTileSize;
                double partialTileOffsetZ = capi.World.Player.Entity.Pos.Z % CloudTileSize;

                Mat4d.Translate(mvMatd, mvMatd, new double[] {
                    windOffsetX - partialTileOffsetX,
                    (int)(0.8627 * capi.World.BlockAccessor.MapSizeY) + 0.5 - capi.World.Player.Entity.Pos.Y,
                    windOffsetZ - partialTileOffsetZ
                });

                // Basic model view matrix
                float[] mvMatf = new float[16];
                for (int i = 0; i < 16; i++)
                {
                    mvMatf[i] = (float)mvMatd[i];
                }

                prog.UniformMatrix("modelViewMatrix", mvMatf);
                capi.Render.RenderMeshInstanced(cloudTilesMeshRef, QuantityCloudTiles);
            }
            capi.Render.GlPopMatrix();


            // Very slightly rotate all the clouds so it looks better when they pass through blocks

            // Putting this line before translate = Clouds no longer centered around the player
            // Putting it after the translate = Clouds hop by a few pixels on every reload
            // Need to find a correct solution for this
            // Mat4.Rotate(mv, mv, 0.04f, new float[] { 0, 1, 0 });


            prog.Stop();
        }