java类net.minecraft.client.renderer.vertex.VertexFormatElement的实例源码

public static void postDraw(EnumUsage attrType, VertexFormat format, int element, int stride, ByteBuffer buffer)
{
    VertexFormatElement attr = format.getElement(element);
    switch(attrType)
    {
        case POSITION:
            glDisableClientState(GL_VERTEX_ARRAY);
            break;
        case NORMAL:
            glDisableClientState(GL_NORMAL_ARRAY);
            break;
        case COLOR:
            glDisableClientState(GL_COLOR_ARRAY);
            // is this really needed?
            GlStateManager.resetColor();
            break;
        case UV:
            OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit + attr.getIndex());
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
            OpenGlHelper.setClientActiveTexture(OpenGlHelper.defaultTexUnit);
            break;
        case PADDING:
            break;
        case GENERIC:
            glDisableVertexAttribArray(attr.getIndex());
        default:
            FMLLog.severe("Unimplemented vanilla attribute upload: %s", attrType.getDisplayName());
    }
}

public static void pack(float[] from, int[] to, VertexFormat formatTo, int v, int e)
{
    VertexFormatElement element = formatTo.getElement(e);
    int vertexStart = v * formatTo.getNextOffset() + formatTo.getOffset(e);
    int count = element.getElementCount();
    VertexFormatElement.EnumType type = element.getType();
    int size = type.getSize();
    int mask = (256 << (8 * (size - 1))) - 1;
    for(int i = 0; i < 4; i++)
    {
        if(i < count)
        {
            int pos = vertexStart + size * i;
            int index = pos >> 2;
            int offset = pos & 3;
            int bits = 0;
            float f = i < from.length ? from[i] : 0;
            if(type == VertexFormatElement.EnumType.FLOAT)
            {
                bits = Float.floatToRawIntBits(f);
            }
            else if(
                type == VertexFormatElement.EnumType.UBYTE ||
                type == VertexFormatElement.EnumType.USHORT ||
                type == VertexFormatElement.EnumType.UINT
            )
            {
                bits = (int)(f * mask);
            }
            else
            {
                bits = (int)(f * mask / 2);
            }
            to[index] &= ~(mask << (offset * 8));
            to[index] |= (((bits & mask) << (offset * 8)));
            // TODO handle overflow into to[index + 1]
        }
    }
}

public List<RealmsVertexFormatElement> getElements()
{
    List<RealmsVertexFormatElement> list = Lists.<RealmsVertexFormatElement>newArrayList();

    for (VertexFormatElement vertexformatelement : this.v.getElements())
    {
        list.add(new RealmsVertexFormatElement(vertexformatelement));
    }

    return list;
}

private void nextVertexFormatIndex()
{
    ++this.vertexFormatIndex;
    this.vertexFormatIndex %= this.vertexFormat.getElementCount();
    this.vertexFormatElement = this.vertexFormat.getElement(this.vertexFormatIndex);

    if (this.vertexFormatElement.getUsage() == VertexFormatElement.EnumUsage.PADDING)
    {
        this.nextVertexFormatIndex();
    }
}

@SuppressWarnings("incomplete-switch")
public void draw(VertexBuffer vertexBufferIn)
{
    if (vertexBufferIn.getVertexCount() > 0)
    {
        VertexFormat vertexformat = vertexBufferIn.getVertexFormat();
        int i = vertexformat.getNextOffset();
        ByteBuffer bytebuffer = vertexBufferIn.getByteBuffer();
        List<VertexFormatElement> list = vertexformat.getElements();

        for (int j = 0; j < list.size(); ++j)
        {
            VertexFormatElement vertexformatelement = (VertexFormatElement)list.get(j);
            VertexFormatElement.EnumUsage vertexformatelement$enumusage = vertexformatelement.getUsage();
            int k = vertexformatelement.getType().getGlConstant();
            int l = vertexformatelement.getIndex();
            bytebuffer.position(vertexformat.getOffset(j));

            // moved to VertexFormatElement.preDraw
            vertexformatelement.getUsage().preDraw(vertexformat, j, i, bytebuffer);
        }

        GlStateManager.glDrawArrays(vertexBufferIn.getDrawMode(), 0, vertexBufferIn.getVertexCount());
        int i1 = 0;

        for (int j1 = list.size(); i1 < j1; ++i1)
        {
            VertexFormatElement vertexformatelement1 = (VertexFormatElement)list.get(i1);
            VertexFormatElement.EnumUsage vertexformatelement$enumusage1 = vertexformatelement1.getUsage();
            int k1 = vertexformatelement1.getIndex();

            // moved to VertexFormatElement.postDraw
            vertexformatelement1.getUsage().postDraw(vertexformat, i1, i, bytebuffer);
        }
    }

    vertexBufferIn.reset();
}

public RenderGlobal(Minecraft mcIn)
{
    this.mc = mcIn;
    this.renderManager = mcIn.getRenderManager();
    this.renderEngine = mcIn.getTextureManager();
    this.renderEngine.bindTexture(FORCEFIELD_TEXTURES);
    GlStateManager.glTexParameteri(3553, 10242, 10497);
    GlStateManager.glTexParameteri(3553, 10243, 10497);
    GlStateManager.bindTexture(0);
    this.updateDestroyBlockIcons();
    this.vboEnabled = OpenGlHelper.useVbo();

    if (this.vboEnabled)
    {
        this.renderContainer = new VboRenderList();
        this.renderChunkFactory = new VboChunkFactory();
    }
    else
    {
        this.renderContainer = new RenderList();
        this.renderChunkFactory = new ListChunkFactory();
    }

    this.vertexBufferFormat = new VertexFormat();
    this.vertexBufferFormat.addElement(new VertexFormatElement(0, VertexFormatElement.EnumType.FLOAT, VertexFormatElement.EnumUsage.POSITION, 3));
    this.generateStars();
    this.generateSky();
    this.generateSky2();
}

@Override
public void put(
        final int element,
        final float... data )
{
    final VertexFormatElement e = getVertexFormat().getElement( element );
    if ( e.getUsage() == EnumUsage.UV && e.getIndex() != 1 )
    {
        sumU += data[0];
        sumV += data[1];
        ++vertCount;
    }
}

private FlattenedModelCache()
{
    this.cache = CacheBuilder.newBuilder().weakKeys().expireAfterAccess(10, TimeUnit.MINUTES)
            .build(new CacheLoader<IBakedModel, IBakedModel>()
            {
                @Override
                public IBakedModel load(final IBakedModel key)
                {
                    IBakedModel model = ForgeHooksClient.handleCameraTransforms(key,
                            ItemCameraTransforms.TransformType.GUI, false);

                    if (model.isGui3d() && !model.isBuiltInRenderer())
                    {
                        model = ModelTransformer.transform(model, null, 0, (quad, element, data) ->
                        {
                            if (element.getUsage() == VertexFormatElement.EnumUsage.NORMAL)
                            {
                                data[0] /= 1.5f;
                                data[2] *= 1.7f;
                            }
                            return data;
                        });
                    }
                    return model;
                }
            });
}

@Override
public void put(int e, float... data) {
    VertexFormat format = getVertexFormat();

    VertexFormatElement fmte = format.getElement(e);
    switch (fmte.getUsage()) {
        case POSITION:
            ccrs.vert.vec.set(data).add(offset);
            break;
        case UV:
            if (fmte.getIndex() == 0) {
                ccrs.vert.uv.set(data[0], data[1]);
            } else {
                ccrs.brightness = (int) (data[1] * 0xFFFF / 2) << 16 | (int) (data[0] * 0xFFFF / 2);
            }
            break;
        case COLOR:
            ccrs.colour = Colour.packRGBA(data);
            break;
        case NORMAL:
            ccrs.normal.set(data);
            break;
        case PADDING:
            break;
        default:
            throw new UnsupportedOperationException("Generic vertex format element");
    }
    if (e == format.getElementCount() - 1) {
        ccrs.writeVert();
    }
}

public void writeVert() {
    if (r instanceof BakingVertexBuffer) {
        ((BakingVertexBuffer) r).setSprite(sprite);
    }
    for (int e = 0; e < fmt.getElementCount(); e++) {
        VertexFormatElement fmte = fmt.getElement(e);
        switch (fmte.getUsage()) {
            case POSITION:
                r.pos(vert.vec.x, vert.vec.y, vert.vec.z);
                break;
            case UV:
                if (fmte.getIndex() == 0) {
                    r.tex(vert.uv.u, vert.uv.v);
                } else {
                    r.lightmap(brightness >> 16 & 65535, brightness & 65535);
                }
                break;
            case COLOR:
                if (r.isColorDisabled()) {
                    //-_- Fucking mojang..
                    r.nextVertexFormatIndex();
                } else {
                    r.color(colour >>> 24, colour >> 16 & 0xFF, colour >> 8 & 0xFF, alphaOverride >= 0 ? alphaOverride : colour & 0xFF);
                }
                break;
            case NORMAL:
                r.normal((float) normal.x, (float) normal.y, (float) normal.z);
                break;
            case PADDING:
                break;
            default:
                throw new UnsupportedOperationException("Generic vertex format element");
        }
    }
    r.endVertex();
}