@Override public Renderable obtain() { Renderable renderable = super.obtain(); // super.obtain resets the following // renderable.environment = null; // renderable.material = null; // renderable.meshPart.set("", null, 0, 0, 0); // renderable.shader = null; // renderable.userData = null; // built in as of libgdx 1.9.6 // https://github.com/libgdx/libgdx/pull/4550 // custom renderable.worldTransform.idt(); return renderable; }
public static Renderable draw() { Player player = Cubes.getClient().player; ItemTool.MiningTarget currentlyMining = player.getCurrentlyMining(); if (currentlyMining == null) return null; BlockReference position = currentlyMining.target; float percent = currentlyMining.time / currentlyMining.totalTime; percent -= 1f / (1f + num); if (percent <= 0f) return null; int n = (int) Math.floor(percent * num); float f = 1f / 128f; Renderable renderable = new Renderable(); renderable.worldTransform.translate(position.blockX - f, position.blockY - f, position.blockZ - f); renderable.worldTransform.scl(1f + f + f); renderable.meshPart.primitiveType = GL20.GL_TRIANGLES; renderable.meshPart.offset = n * (6 * 6); renderable.meshPart.size = 6 * 6; renderable.meshPart.mesh = mesh; renderable.material = material; return renderable; }
private void getShaderIf(int shader, Renderable renderable, boolean fogFlag, boolean aoFlag) { if (shaders[shader] == null) { if (shader == 0) { shaders[shader] = new CubesShader(renderable); } else { ArrayList<Feature> f = new ArrayList<Feature>(); if (fogFlag) f.add(new FogFeature()); if (aoFlag) f.add(new AmbientOcclusionFeature()); shaders[shader] = new FeatureShader(renderable, f); } ShaderProgram program = shaders[shader].program; if (!program.isCompiled()) { Log.error("Failed to compile shader"); Log.error("Shader log: \n" + program.getLog()); Log.error("Fragment shader source: \n" + program.getFragmentShaderSource()); Log.error("Vertex shader source: \n" + program.getVertexShaderSource()); throw new CubesException("Failed to compile shader"); } shaders[shader].init(); } }
@Override public Shader getShader(Renderable renderable) { int shader = 0; boolean fogFlag = Settings.getBooleanSettingValue(Settings.GRAPHICS_FOG); if (renderable.userData instanceof RenderingSettings) fogFlag &= ((RenderingSettings) renderable.userData).fogEnabled; if (fogFlag) shader |= FEATURE_FOG; boolean aoFlag = renderable.meshPart.mesh.getVertexAttributes() == CubesVertexAttributes.VERTEX_ATTRIBUTES_AO; if (aoFlag) shader |= FEATURE_AO; getShaderIf(shader, renderable, fogFlag, aoFlag); return shaders[shader]; }
public static void setWorldTransform(Renderable renderable, boolean isMoon) { Vector3 pos = Cubes.getClient().player.position; int r = 512; float f = (float) (Cubes.getClient().world.getTime() - (World.MAX_TIME / 4)) / (float) World.MAX_TIME; if (isMoon) f += 0.5f; f %= 1; float x = (pos.x + (r * Math.cos(f * 2 * Math.PI))); float y = (pos.y + (r * Math.sin(f * 2 * Math.PI))); float z = pos.z; renderable.worldTransform.setToTranslation(x, y, z); renderable.worldTransform.scl(75f); renderable.worldTransform.rotate(Vector3.Z, (f - 0.25f % 1) * 360); }
@Override public Renderable obtain () { Renderable renderable = super.obtain(); // super.obtain resets the following //renderable.environment = null; //renderable.material = null; //renderable.meshPart.set("", null, 0, 0, 0); //renderable.shader = null; // renderable.userData = null; // built in as of libgdx 1.9.6 // https://github.com/libgdx/libgdx/pull/4550 // custom renderable.worldTransform.idt(); return renderable; }
private String createPrefix(Renderable renderable) { String prefix = ""; if (params.useBones) { prefix += "#define numBones " + 12 + "\n"; final int n = renderable.meshPart.mesh.getVertexAttributes().size(); for (int i = 0; i < n; i++) { final VertexAttribute attr = renderable.meshPart.mesh.getVertexAttributes().get(i); if (attr.usage == VertexAttributes.Usage.BoneWeight) { prefix += "#define boneWeight" + attr.unit + "Flag\n"; } } } return prefix; }
protected final int[] getAttributeLocations(Renderable renderable) { final IntIntMap attributes = new IntIntMap(); final VertexAttributes attrs = renderable.meshPart.mesh.getVertexAttributes(); final int c = attrs.size(); for (int i = 0; i < c; i++) { final VertexAttribute attr = attrs.get(i); final int location = program.getAttributeLocation(attr.alias); if (location >= 0) attributes.put(attr.getKey(), location); } tempArray.clear(); final int n = attrs.size(); for (int i = 0; i < n; i++) { tempArray.add(attributes.get(attrs.get(i).getKey(), -1)); } return tempArray.items; }
@Override public void render(Renderable renderable) { program.setUniformMatrix(u_worldTrans, renderable.worldTransform); program.setUniformf(albedo, albedoColor); program.setUniformf(metallic, metallicValue); program.setUniformf(ambientOcclusion, ambientOcclusionValue); program.setUniformf(vLight0, new Vector3(2.00f,-2.00f,-2.00f)); ref.bind(0); program.setUniformi(sCubemapTexture, 0); program.setUniformf(vRoughness, new Vector2(rougness,5)); if (currentMesh != renderable.meshPart.mesh) { if (currentMesh != null) currentMesh.unbind(program, tempArray.items); currentMesh = renderable.meshPart.mesh; currentMesh.bind(program, getAttributeLocations(renderable)); } renderable.meshPart.mesh.render(program, renderable.meshPart.primitiveType, renderable.meshPart.offset, renderable.meshPart.size,false); }
@Override public void render(final Renderable renderable, final Attributes combinedAttributes) { boolean firstCall = true; for(final LightWrapper light : lights) { light.applyToShader(program); if(firstCall){ context.setDepthTest(GL20.GL_LEQUAL); context.setBlending(false, GL20.GL_ONE, GL20.GL_ONE); super.render(renderable, combinedAttributes); firstCall = false; }else{ context.setDepthTest(GL20.GL_EQUAL); context.setBlending(true, GL20.GL_ONE, GL20.GL_ONE); renderable.meshPart.render(program, false); } } }
@Override public void render(final Renderable renderable, final Attributes combinedAttributes) { renderable.meshPart.primitiveType = GL20.GL_TRIANGLES; final boolean[] firstCall = {true}; lights.forEach(l -> { l.applyToShader(program); if(Gdx.input.isKeyJustPressed(Input.Keys.L)) for (String s : program.getUniforms()) { System.out.println(s); } if(true) { context.setDepthTest(GL20.GL_LEQUAL); context.setBlending(false, GL20.GL_ONE, GL20.GL_ONE); super.render(renderable, combinedAttributes); firstCall[0] = false; }else{ context.setDepthTest(GL20.GL_EQUAL); context.setBlending(true, GL20.GL_ONE, GL20.GL_ONE); MeshPart part = renderable.meshPart; part.mesh.render(program, part.primitiveType, part.offset, part.size, false); } }); }
@Override public void render(Renderable renderable, Attributes combinedAttributes) { // context.setCullFace(GL_BACK); // Classic depth test context.setDepthTest(GL20.GL_LEQUAL); // Deactivate blending on first pass context.setBlending(false, GL20.GL_ONE, GL20.GL_ONE); context.setDepthMask(true); if (!combinedAttributes.has(BlendingAttribute.Type)) context.setBlending(false, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA); super.render(renderable, combinedAttributes); // program.begin(); // super.render(renderable, combinedAttributes); // program.end(); }
@Override public Shader getShader(Renderable renderable) { // небольшой такой КОСТЫЛЬ из за убогости LibGDX // явно укажем версию шейдеров. и немного поправим совместимость... ShaderProgram.prependVertexCode = SHADER_VERSION + "\n"; ShaderProgram.prependFragmentCode = SHADER_VERSION + "\n"; Shader shader = super.getShader(renderable); ShaderProgram.prependVertexCode = null; ShaderProgram.prependFragmentCode = null; return shader; }
@Override public void render(final Renderable renderable) { // if (!renderable.material.has(BlendingAttribute.Type)) // { // context.setBlending(false, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA); // } // else // { // context.setBlending(true, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA); // } // if (!renderable.material.has(BlendingAttribute.Type)) // { // context.setDepthTest(GL20.GL_LEQUAL); // context.setBlending(false, GL20.GL_ONE, GL20.GL_ONE); // } // else // { // context.setDepthTest(GL20.GL_EQUAL); // context.setBlending(true, GL20.GL_ONE, GL20.GL_ONE); // } super.render(renderable); }
@Override public void render(Renderable renderable) { // texture uniform CubemapAttribute cubemapAttribute = ((CubemapAttribute) (renderable.material .get(CubemapAttribute.EnvironmentMap))); if (cubemapAttribute != null) { set(UNIFORM_TEXTURE, cubemapAttribute.textureDescription); } // Fog Fog fog = ((MundusEnvironment) renderable.environment).getFog(); if (fog == null) { set(UNIFORM_FOG, 0); } else { set(UNIFORM_FOG, 1); set(UNIFORM_FOG_COLOR, fog.color); } renderable.meshPart.render(program); }
@Override public void render(Renderable renderable) { final MundusEnvironment env = (MundusEnvironment) renderable.environment; setLights(env); setTerrainSplatTextures(renderable); set(UNIFORM_TRANS_MATRIX, renderable.worldTransform); // Fog final Fog fog = env.getFog(); if (fog == null) { set(UNIFORM_FOG_DENSITY, 0f); set(UNIFORM_FOG_GRADIENT, 0f); } else { set(UNIFORM_FOG_DENSITY, fog.density); set(UNIFORM_FOG_GRADIENT, fog.gradient); set(UNIFORM_FOG_COLOR, fog.color); } // bind attributes, bind mesh & render; then unbinds everything renderable.meshPart.render(program); }
public UberShader(Renderable renderable, Config config) { super(renderable, config); String prefix = DefaultShader.createPrefix(renderable, config); if (renderable.material.has(VertexColorTextureBlend.Red)) { prefix += "#define redVertexColorBlendFlag\n"; } if (renderable.material.has(VertexColorTextureBlend.Green)) { prefix += "#define greenVertexColorBlendFlag\n"; } if (renderable.material.has(VertexColorTextureBlend.Blue)) { prefix += "#define blueVertexColorBlendFlag\n"; } program = new ShaderProgram(prefix + config.vertexShader, prefix + config.fragmentShader); if (!program.isCompiled()) { Gdx.app.debug(TAG, program.getLog()); } }
public GameRenderer(Viewport viewport, Camera camera, GameEngine engine) { this.viewport = viewport; this.camera = camera; this.engine = engine; shapeRenderer = new MyShapeRenderer(); shapeRenderer.setAutoShapeType(true); spriteBatch = new SpriteBatch(); font = new BitmapFont(); font.setColor(Color.WHITE); font.setUseIntegerPositions(false); font.getData().setScale(0.01f); shadowBatch = new ModelBatch(new DepthShaderProvider()); ShaderProgram.pedantic = false; final String vertUber = Gdx.files.internal("shaders/uber.vert").readString(); final String fragUber = Gdx.files.internal("shaders/uber.frag").readString(); modelBatch = new ModelBatch(new DefaultShaderProvider(vertUber, fragUber) { @Override protected Shader createShader(final Renderable renderable) { return new UberShader(renderable, config); } }); }
@Override public void create () { modelBatch = new ModelBatch(new BaseShaderProvider() { @Override protected Shader createShader (Renderable renderable) { return new TestShader(); } }); cam = new PerspectiveCamera(67, Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); cam.position.set(10f, 10f, 10f); cam.lookAt(0, 0, 0); cam.near = 0.1f; cam.far = 300f; cam.update(); camController = new CameraInputController(cam); Gdx.input.setInputProcessor(camController); Material material = new Material(new TestAttribute(1f)); ModelBuilder builder = new ModelBuilder(); model = builder.createCone(5, 5, 5, 20, material, Usage.Position); instance = new ModelInstance(model); testAttribute = (TestAttribute)instance.materials.get(0).get(TestAttribute.ID); }
private void renderWireframe() { context.begin(); { shapeRenderer.setProjectionMatrix(camera.combined); shapeRenderer.begin(ShapeRenderer.ShapeType.Line); { for (int i = 0; i < renderables.size; i++) { Renderable renderable = renderables.get(i); if (BaseRenderable.class.isInstance(renderable)) { BaseRenderable baseRenderable = (BaseRenderable)renderable; if (baseRenderable.wireframe != null) { shapeRenderer.setTransformMatrix(renderable.worldTransform); baseRenderable.wireframe.render(shapeRenderer, Color.WHITE); } } } } shapeRenderer.end(); } context.end(); }
@Override public void render (final Renderable renderable) { if (renderable.material.has(BlendingAttribute.Type)) { final BlendingAttribute blending = (BlendingAttribute)renderable.material.get(BlendingAttribute.Type); renderable.material.remove(BlendingAttribute.Type); final boolean hasAlphaTest = renderable.material.has(FloatAttribute.AlphaTest); if (!hasAlphaTest) renderable.material.set(alphaTestAttribute); if (blending.opacity >= ((FloatAttribute)renderable.material.get(FloatAttribute.AlphaTest)).value) super.render(renderable); if (!hasAlphaTest) renderable.material.remove(FloatAttribute.AlphaTest); renderable.material.set(blending); } else super.render(renderable); }
public ParticleShader(final Renderable renderable, final Config config, final ShaderProgram shaderProgram) { this.config = config; this.program = shaderProgram; this.renderable = renderable; materialMask = renderable.material.getMask() | optionalAttributes; vertexMask = renderable.mesh.getVertexAttributes().getMask(); if (!config.ignoreUnimplemented && (implementedFlags & materialMask) != materialMask) throw new GdxRuntimeException("Some attributes not implemented yet ("+materialMask+")"); // Global uniforms register(DefaultShader.Inputs.viewTrans, DefaultShader.Setters.viewTrans); register(DefaultShader.Inputs.projViewTrans, DefaultShader.Setters.projViewTrans); register(DefaultShader.Inputs.projTrans, DefaultShader.Setters.projTrans); register(Inputs.screenWidth, Setters.screenWidth); register(DefaultShader.Inputs.cameraUp, Setters.cameraUp); register(Inputs.cameraRight, Setters.cameraRight); register(Inputs.cameraInvDirection, Setters.cameraInvDirection); register(DefaultShader.Inputs.cameraPosition, Setters.cameraPosition); // Object uniforms register(DefaultShader.Inputs.diffuseTexture, DefaultShader.Setters.diffuseTexture); }
@Override public Shader getShader (Renderable renderable) { try { return super.getShader(renderable); } catch (Throwable e) { if (tempFolder != null && Gdx.app.getType() == ApplicationType.Desktop) Gdx.files.absolute(tempFolder).child(name + ".log.txt").writeString(e.getMessage(), false); if (!revert()) { Gdx.app.error("ShaderCollectionTest", e.getMessage()); throw new GdxRuntimeException("Error creating shader, cannot revert to default shader", e); } error = true; Gdx.app.error("ShaderTest", "Could not create shader, reverted to default shader.", e); return super.getShader(renderable); } }
@Override public void render(Renderable renderable) { if (renderable.userData instanceof RenderingSettings && ((RenderingSettings) renderable.userData).lightOverride != -1) { program.setUniformf(u_lightoverride, ((RenderingSettings) renderable.userData).lightOverride); lightoverride = true; } else if (lightoverride) { program.setUniformf(u_lightoverride, -1f); lightoverride = false; } super.render(renderable); }
@Override public void getRenderables(Array<Renderable> renderables, Pool<Renderable> pool) { if (area == null || !update() || meshs.size() == 0) return; renderedThisFrame++; for (AreaMesh mesh : meshs) { renderedMeshesThisFrame++; renderables.add(mesh.renderable(pool)); } }
@Override public Shader getShader(Renderable renderable) { int shader = 0; boolean fogFlag = Settings.getBooleanSettingValue(Settings.GRAPHICS_FOG); if (renderable.userData instanceof RenderingSettings) fogFlag &= ((RenderingSettings) renderable.userData).fogEnabled; if (fogFlag) shader |= FEATURE_FOG; boolean aoFlag = renderable.meshPart.mesh.getVertexAttributes() == CubesVertexAttributes.VERTEX_ATTRIBUTES_AO; if (aoFlag) shader |= FEATURE_AO; if (shaders[shader] == null) { if (shader == 0) { shaders[shader] = new CubesShader(renderable); } else { ArrayList<Feature> f = new ArrayList<Feature>(); if (fogFlag) f.add(new FogFeature()); if (aoFlag) f.add(new AmbientOcclusionFeature()); shaders[shader] = new FeatureShader(renderable, f); } ShaderProgram program = shaders[shader].program; if (!program.isCompiled()) { Log.error("Failed to compile shader"); Log.error("Shader log: \n" + program.getLog()); Log.error("Fragment shader source: \n" + program.getFragmentShaderSource()); Log.error("Vertex shader source: \n" + program.getVertexShaderSource()); throw new CubesException("Failed to compile shader"); } shaders[shader].init(); } return shaders[shader]; }
public static void setWorldTransform(Renderable renderable, boolean isMoon) { Vector3 pos = Cubes.getClient().player.position; int r = 512; float f = (float) (Cubes.getClient().world.getTime() - (World.MAX_TIME / 4)) / (float) World.MAX_TIME; if (isMoon) f += 0.5f; f %= 1; float x = (float) (pos.x + (r * Math.cos(f * 2 * Math.PI))); float y = (float) (pos.y + (r * Math.sin(f * 2 * Math.PI))); float z = pos.z; renderable.worldTransform.setToTranslation(x, y, z); renderable.worldTransform.scl(75f); renderable.worldTransform.rotate(Vector3.Z, (f - 0.25f % 1) * 360); }
@Override protected Shader createShader(final Renderable renderable) { DepthMapShader.Params params = new DepthMapShader.Params(); params.useBones = ShaderUtils.useBones(renderable); return new DepthMapShader(renderable, params); }
@Override public void render(final Renderable renderable) { if (!renderable.material.has(BlendingAttribute.Type)) { context.setBlending(false, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA); } else { context.setBlending(true, GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA); } updateBones(renderable); super.render(renderable); }
private void updateBones(Renderable renderable) { if (renderable.bones != null) { bones = new float[renderable.bones.length * 16]; for (int i = 0; i < bones.length; i++) { final int idx = i / 16; bones[i] = (idx >= renderable.bones.length || renderable.bones[idx] == null) ? idtMatrix.val[i % 16] : renderable.bones[idx].val[i % 16]; } program.setUniformMatrix4fv("u_bones", bones, 0, bones.length); } }
@Override protected Shader createShader(Renderable renderable) { PBRShader.Params params = new PBRShader.Params(); params.albedo = ShaderUtils.hasAlbedo(renderable); params.metalness = ShaderUtils.hasMetalness(renderable); params.roughness = ShaderUtils.hasRoughness(renderable); params.normal = ShaderUtils.hasPbrNormal(renderable); params.ambientOcclusion = ShaderUtils.hasAmbientOcclusion(renderable); params.useBones = ShaderUtils.useBones(renderable); params.lit = ShaderUtils.hasLights(environment); params.gammaCorrection = ShaderUtils.useGammaCorrection(environment); params.imageBasedLighting = ShaderUtils.useImageBasedLighting(environment); return new PBRShader(renderable, environment, params); }
@Override public boolean canRender(Renderable instance) { boolean diffuse = ShaderUtils.hasAlbedo(instance) == params.albedo; boolean metalness = ShaderUtils.hasMetalness(instance) == params.metalness; boolean roughness = ShaderUtils.hasRoughness(instance) == params.roughness; boolean normal = ShaderUtils.hasPbrNormal(instance) == params.normal; boolean ambientOcclusion = ShaderUtils.hasAmbientOcclusion(instance) == params.ambientOcclusion; boolean bones = ShaderUtils.useBones(instance) == params.useBones; boolean lit = ShaderUtils.hasLights(instance.environment) == params.lit; boolean gammaCorrection = ShaderUtils.useGammaCorrection(instance.environment) == params.gammaCorrection; boolean imageBasedLighting = ShaderUtils.useImageBasedLighting(instance.environment) == params.imageBasedLighting; return diffuse && metalness && roughness && normal && ambientOcclusion && bones && lit && gammaCorrection && imageBasedLighting; }
protected void allocRenderable() { renderable = new Renderable(); renderable.meshPart.primitiveType = GL20.GL_POINTS; renderable.meshPart.offset = 0; renderable.material = new Material(new BlendingAttribute(GL20.GL_ONE, GL20.GL_ONE_MINUS_SRC_ALPHA, 1f), new DepthTestAttribute(GL20.GL_LEQUAL, false), TextureAttribute.createDiffuse((Texture) null)); }
public static boolean hasDiffuse(Renderable renderable) { boolean res = false; TextureAttribute attribute = (TextureAttribute) renderable.material.get(TextureAttribute.Diffuse); if (attribute != null && attribute.textureDescription.texture != null) { res = true; } return res; }
public static boolean hasNormal(Renderable renderable) { boolean res = false; TextureAttribute attribute = (TextureAttribute) renderable.material.get(TextureAttribute.Normal); if (attribute != null && attribute.textureDescription.texture != null) { res = true; } return res; }