* Copyright 2013 MovingBlocks

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* TODO: This should be made generic (no explicit shader or mesh) and ported directly into WorldRenderer? Later note: some GelCube functionality moved to a module

*

* @author Immortius <immortius@gmail.com>

*/

    private static final Logger logger = LoggerFactory.getLogger(MeshRenderer.class);

    @In

    private NetworkSystem network;

    @In

    private LocalPlayer localPlayer;

    @In

    private Config config;

    @In

    private WorldRenderer worldRenderer;

    @In

    private WorldProvider worldProvider;

    private SetMultimap<Material, EntityRef> opaqueMesh = HashMultimap.create();

    private SetMultimap<Material, EntityRef> translucentMesh = HashMultimap.create();

    private Map<EntityRef, Material> opaqueEntities = Maps.newHashMap();

    private Map<EntityRef, Material> translucentEntities = Maps.newHashMap();

    private NearestSortingList opaqueMeshSorter = new NearestSortingList();

    private NearestSortingList translucentMeshSorter = new NearestSortingList();

    private int lastRendered;

    @Override

    public void initialise() {

        opaqueMeshSorter.initialise(worldRenderer.getActiveCamera());

        translucentMeshSorter.initialise(worldRenderer.getActiveCamera());

    }

    @Override

    public void shutdown() {

        opaqueMeshSorter.stop();

        translucentMeshSorter.stop();

    }

    @ReceiveEvent(components = {MeshComponent.class, LocationComponent.class})

    public void onNewMesh(OnActivatedComponent event, EntityRef entity) {

        addMesh(entity);

    }

    private void addMesh(EntityRef entity) {

        MeshComponent meshComp = entity.getComponent(MeshComponent.class);

        // Don't render if hidden from owner (need to improve for third person)

        if (meshComp.hideFromOwner) {

            ClientComponent owner = network.getOwnerEntity(entity).getComponent(ClientComponent.class);

            if (owner != null && owner.local) {

                return;

            }

        }

        if (meshComp.material != null) {

            if (meshComp.translucent) {

                translucentMesh.put(meshComp.material, entity);

                translucentEntities.put(entity, meshComp.material);

                translucentMeshSorter.add(entity);

            } else {

                opaqueMesh.put(meshComp.material, entity);

                opaqueEntities.put(entity, meshComp.material);

                opaqueMeshSorter.add(entity);

            }

        }

    }

    @ReceiveEvent(components = {CharacterComponent.class, MeshComponent.class})

    public void onLocalMesh(OnChangedComponent event, EntityRef entity) {

        removeMesh(entity);

        addMesh(entity);

    }

    @ReceiveEvent(components = {MeshComponent.class})

    public void onChangeMesh(OnChangedComponent event, EntityRef entity) {

        removeMesh(entity);

        addMesh(entity);

    }

    private void removeMesh(EntityRef entity) {

        Material mat = opaqueEntities.remove(entity);

        if (mat != null) {

            opaqueMesh.remove(mat, entity);

            opaqueMeshSorter.remove(entity);

        } else {

            mat = translucentEntities.remove(entity);

            if (mat != null) {

                translucentMesh.remove(mat, entity);

                translucentMeshSorter.remove(entity);

            }

        }

    }

    @ReceiveEvent(components = {MeshComponent.class, LocationComponent.class})

    public void onDestroyMesh(BeforeDeactivateComponent event, EntityRef entity) {

        removeMesh(entity);

    }

    @Override

    public void renderAlphaBlend() {

        if (config.getRendering().isRenderNearest()) {

            renderAlphaBlend(Arrays.asList(translucentMeshSorter.getNearest(config.getRendering().getMeshLimit())));

        } else {

            renderAlphaBlend(translucentEntities.keySet());

        }

    }

    private void renderAlphaBlend(Iterable<EntityRef> entityRefs) {

        Vector3f cameraPosition = worldRenderer.getActiveCamera().getPosition();

        for (EntityRef entity : entityRefs) {

            MeshComponent meshComp = entity.getComponent(MeshComponent.class);

            meshComp.material.enable();

            LocationComponent location = entity.getComponent(LocationComponent.class);

            if (location == null) {

                continue;

            }

            Quat4f worldRot = location.getWorldRotation();

            Vector3f worldPos = location.getWorldPosition();

            float worldScale = location.getWorldScale();

            AABB aabb = meshComp.mesh.getAABB().transform(worldRot, worldPos, worldScale);

            if (worldRenderer.isAABBVisible(aabb)) {

                glPushMatrix();

                glTranslated(worldPos.x - cameraPosition.x, worldPos.y - cameraPosition.y, worldPos.z - cameraPosition.z);

                AxisAngle4f rot = new AxisAngle4f();

                rot.set(worldRot);

                glRotatef(TeraMath.RAD_TO_DEG * rot.angle, rot.x, rot.y, rot.z);

                glScalef(worldScale, worldScale, worldScale);

                meshComp.material.setFloat4("colorOffset", meshComp.color.rf(), meshComp.color.gf(), meshComp.color.bf(), meshComp.color.af(), true);

                meshComp.material.setFloat("light", worldRenderer.getRenderingLightValueAt(worldPos), true);

                meshComp.mesh.render();

                glPopMatrix();

            }

        }

    }

    @Override

    public void renderOpaque() {

        if (config.getRendering().isRenderNearest()) {

            SetMultimap<Material, EntityRef> entitiesToRender = HashMultimap.create();

            for (EntityRef entity : Arrays.asList(opaqueMeshSorter.getNearest(config.getRendering().getMeshLimit()))) {

                MeshComponent meshComp = entity.getComponent(MeshComponent.class);

                if (meshComp != null && meshComp.material != null) {

                    entitiesToRender.put(meshComp.material, entity);

                }

            }

            renderOpaque(entitiesToRender);

        } else {

            renderOpaque(opaqueMesh);

        }

    }

    private void renderOpaque(SetMultimap<Material, EntityRef> meshByMaterial) {

        Vector3f cameraPosition = worldRenderer.getActiveCamera().getPosition();

        Quat4f worldRot = new Quat4f();

        Vector3f worldPos = new Vector3f();

        Matrix4f matrixWorldSpace = new Matrix4f();

        Transform transWorldSpace = new Transform();

        Matrix4f matrixCameraSpace = new Matrix4f();

        FloatBuffer tempMatrixBuffer44 = BufferUtils.createFloatBuffer(16);

        FloatBuffer tempMatrixBuffer33 = BufferUtils.createFloatBuffer(12);

        for (Material material : meshByMaterial.keySet()) {

            OpenGLMesh lastMesh = null;

            material.enable();

            material.setFloat("sunlight", 1.0f);

            material.setFloat("blockLight", 1.0f);

            material.setMatrix4("projectionMatrix", worldRenderer.getActiveCamera().getProjectionMatrix());

            material.bindTextures();

            Set<EntityRef> entities = meshByMaterial.get(material);

            lastRendered = entities.size();

            for (EntityRef entity : entities) {

                MeshComponent meshComp = entity.getComponent(MeshComponent.class);

                LocationComponent location = entity.getComponent(LocationComponent.class);

                if (location == null || meshComp.mesh == null || !worldProvider.isBlockRelevant(location.getWorldPosition())) {

                    continue;

                }

                if (meshComp.mesh.isDisposed()) {

                    logger.error("Attempted to render disposed mesh");

                    continue;

                }

                location.getWorldRotation(worldRot);

                location.getWorldPosition(worldPos);

                float worldScale = location.getWorldScale();

                matrixWorldSpace.set(worldRot, worldPos, worldScale);

                transWorldSpace.set(matrixWorldSpace);

                Vector3f worldPositionCameraSpace = new Vector3f();

                worldPositionCameraSpace.sub(worldPos, cameraPosition);

                matrixCameraSpace.set(worldRot, worldPositionCameraSpace, worldScale);

                AABB aabb = meshComp.mesh.getAABB().transform(transWorldSpace);

                if (worldRenderer.isAABBVisible(aabb)) {

                    if (meshComp.mesh != lastMesh) {

                        if (lastMesh != null) {

                            lastMesh.postRender();

                        }

                        lastMesh = (OpenGLMesh) meshComp.mesh;

                        lastMesh.preRender();

                    }

                    Matrix4f modelViewMatrix = MatrixUtils.calcModelViewMatrix(worldRenderer.getActiveCamera().getViewMatrix(), matrixCameraSpace);

                    MatrixUtils.matrixToFloatBuffer(modelViewMatrix, tempMatrixBuffer44);

                    material.setMatrix4("worldViewMatrix", tempMatrixBuffer44, true);

                    MatrixUtils.matrixToFloatBuffer(MatrixUtils.calcNormalMatrix(modelViewMatrix), tempMatrixBuffer33);

                    material.setMatrix3("normalMatrix", tempMatrixBuffer33, true);

                    material.setFloat3("colorOffset", meshComp.color.rf(), meshComp.color.gf(), meshComp.color.bf(), true);

                    material.setFloat("sunlight", worldRenderer.getSunlightValueAt(worldPos), true);

                    material.setFloat("blockLight", worldRenderer.getBlockLightValueAt(worldPos), true);

                    lastMesh.doRender();

                }

            }

            if (lastMesh != null) {

                lastMesh.postRender();

            }

        }

    }

    @Override

    public void renderOverlay() {

    }

    @Override

    public void renderFirstPerson() {

    }

    @Override

    public void renderShadows() {

    }

    public int getLastRendered() {

        return lastRendered;

    }

}