[1.12] Orient Spawned Throwable Entity

[signat]

Hello,

 

Very new to minecraft modding, but I have been making good progress. I have created a custom throwable entity based mostly on EntitySnowBall that works perfectly. However, when I throw it, the model is always rendered in the same orientation with reference to the world. I would like for its rendered orientation to be based on the player so that its its always thrown on edge (its a throwing star) to look more realistic.

 

Here are what I believe to be the relevant portions of my code. Thank you all for your help!

 

ModelThrowingStar Class

@SideOnly(Side.CLIENT)
public class ModelThrowingStar extends ModelBase {
    public ModelRenderer renderer;

    public ModelThrowingStar() {
        this.textureWidth = 16;
        this.textureHeight = 16;

        this.renderer = new ModelRenderer(this, 0, 0);
        this.renderer.setRotationPoint(0.0F, 0.0F, 0.0F);
        this.renderer.addBox(0.0F, 0.0F, 0.0F, 16, 16, 0);
    }

    @Override
    public void render(Entity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float rotationYaw, float rotationPitch, float scale) {
        this.renderer.render(scale);        
    }

 

 

RenderThrowingStar Class

    private final ModelThrowingStar model = new ModelThrowingStar();

@Override
    public void doRender(EntityThrowingStar entity, double x, double y, double z, float entityYaw, float partialTicks)
    {
        GlStateManager.pushMatrix();
        GlStateManager.translate(x, y, z);
        this.bindEntityTexture(entity);
        model.render(entity, partialTicks, 0f, -1f, 0f, 0f, 0.05f);
        GlStateManager.popMatrix();
        super.doRender(entity, x, y, z, entityYaw, partialTicks);
    }

 

EntityThrowingStar Class

public class EntityThrowingStar extends EntityThrowable{
    
    public EntityThrowingStar(World worldIn)
    {
        super(worldIn);
    }

    public EntityThrowingStar(World worldIn, EntityLivingBase throwerIn)
    {
        super(worldIn, throwerIn);
    }

    public EntityThrowingStar(World worldIn, double x, double y, double z)
    {
        super(worldIn, x, y, z);
    }

    /**
     * Handler for {@link World#setEntityState}
     */
    @SideOnly(Side.CLIENT)
    @Override
    public void handleStatusUpdate(byte id)
    {
        if (id == 3)
        {
            for (int i = 0; i < 8; ++i)
            {
                this.world.spawnParticle(EnumParticleTypes.CRIT, this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D);
            }
        }
    }

    /**
     * Called when this EntityThrowable hits a block or entity.
     */
    @Override
    protected void onImpact(RayTraceResult result)
    {
        if (result.entityHit != null)
        {
            int i = 10;

            result.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, this.getThrower()), (float)i);
        }

        if (!this.world.isRemote)
        {
            this.world.setEntityState(this, (byte)3);
            this.setDead();
        }
    }
}

 

ThrowingStar Class (Item Class with the right click action)

@Override
    public ActionResult<ItemStack> onItemRightClick(World worldIn, EntityPlayer playerIn, EnumHand handIn)
    {
        ItemStack itemstack = playerIn.getHeldItem(handIn);

        if (!playerIn.capabilities.isCreativeMode)
        {
            itemstack.shrink(1);
        }

        worldIn.playSound((EntityPlayer)null, playerIn.posX, playerIn.posY, playerIn.posZ, SoundEvents.ENTITY_SNOWBALL_THROW, SoundCategory.NEUTRAL, 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));

        if (!worldIn.isRemote)
        {
            
            EntityThrowingStar entitythrowingstar = new EntityThrowingStar(worldIn, playerIn);
            entitythrowingstar.setHeadingFromThrower(playerIn, playerIn.rotationPitch, playerIn.rotationYaw, 0.0F, 1.5F, 1.0F);
            worldIn.spawnEntity(entitythrowingstar);
            
        }

        playerIn.addStat(StatList.getObjectUseStats(this));
        return new ActionResult<ItemStack>(EnumActionResult.SUCCESS, itemstack);        
    }

 

 

Please let me know if there is other code I should have posted.

[oldcheese]

Alright. I'm not sure how new you are. But in these cases it's always incredibly helpfull to just take a gander at a relevant source class. For example; What throwable projectile manages to always shoot in the correct position? Right. The arrow. 

 

So go into your source folder and go to ForgeSrc/Net/Minecraft/client/renderer/Entity

Here you will find a class called RenderArrow.

 

RenderArrow will have the rotations you'll want to apply using your GlStateManager to make your projectile fully visible, If you're having trouble let me know.

 

Second, your model seems to be 16x16 wide. that's pretty big, nothing you can't fix with scale though. But the rotationpoint is set at 0,0,0 which means it'll be at the very edge. Depending on how you want it to rotate you might want to set it to the middle of your projectile.

 

Third. When you rotate your projectile using the code from RenderArrow your star might always render in a proper position away from your player, but rotated 90 degrees (So it's always in the same position from you, but vertical.) When this happens don't try to rotate with GLStateManager. It's a lot easier to just rotate the base model using something like the following: 

 

        this.setRotationAngles(this.leftprong1, -0.67928211291826F, 0.0F, 0.0F);

(And yes, that's in Rad, not Degrees)

 

 

Sorry if my post rambles a bit. English isn't my first language, but I think this should be all to make your projectile fly off. 

 

 

 

Edit: Also, a little hint. And I'm only saying this because I just worked on my own custom projectile. If you want your projectile to cause particles on hit, look at the EntitySnowball class, if you want to change your Gravity you can simply overwrite the getGravityVelocity() class. And if you want to add particles during the flight you can override the onUpdate class, just make sure to invoke super so you don't mess up impact.  you probably already know this stuff, but still.

Edited September 18, 2017 by oldcheese
oh, also.

[signat]

Thank you, oldcheese! I don't know why I didn't look at RenderArrow in the first place. Adding these lines of code to my RenderThrowingStar class' doRender method gave me the result I was looking for:

 

GlStateManager.rotate(entity.prevRotationYaw + (entity.rotationYaw - entity.prevRotationYaw) * partialTicks - 90.0F, 0.0F, 1.0F, 0.0F);
GlStateManager.rotate(entity.prevRotationPitch + (entity.rotationPitch - entity.prevRotationPitch) * partialTicks, 0.0F, 0.0F, 1.0F);

 

I do have one follow-up question if you have the time. The open GL coding is something that I have never done before. So, my question is:

 

Now that I have the throwing star oriented correctly, I can see that it has no depth. What I mean is that when looking at the side it renders 16 by 16 but on edge, I can only see a tiny vertical line when thrown. I tried changing this in my ModelThrowingStar class:

 

this.renderer.addBox(0.0F, 0.0F, 0.0F, 16, 16, 0);

 

to

 

this.renderer.addBox(0.0F, 0.0F, 0.0F, 16, 16, 1);

 

Where 1 is supposed to be the depth of the box, but it has no effect. Or if the box is rendered at a depth of 1, there is no texture being applied.

 

 

Thanks!

 

[Draco18s]

The box has thickness, but it's using the same texture it has been given for the front face, which is either:

a) rendering the left most edge of pixels

b) rendering the whole things squashed down to a narrow "thing"

 

If you want to render the "edge" pixels like you see when holding an item, you need to render that item's model, which is wholly different than the snowball renderer (which was designed to always face the camera and have no thickness).

[signat]

Thank you, Draco! This makes perfect sense. Do you have a suggestion of a model class I can reference to try and figure out what I need to change? I looked around for something that might be rendering my item model (like when its held in hand) but didn't see it.

[oldcheese]

The only thing you'd have to change is your amount of boxes. You'd probably want a box for the center, then a few rectangles to make the wings. 

 

If you don't feel like writing about twenty boxes I suggest using Qubble

 

which doesn't work that great, but is better than nothing.

 

Ofcourse there's a lot of other box-based modellers that you can use. or you can do it by hand for simple structures. I've made the following  star in about five minutes or so.  And as you can see it's model would take quite a while to code by hand: 

package com.cheese.rpvp.entities.throwables;

import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.Entity;
import org.lwjgl.opengl.GL11;

public class Wing extends ModelBase {
        public ModelRenderer Centersquare;
        public ModelRenderer wing1;
        public ModelRenderer wing1b;
        public ModelRenderer wing1c;
        public ModelRenderer wing1d;
        public ModelRenderer wing2;
        public ModelRenderer wing2b;
        public ModelRenderer wing2c;
        public ModelRenderer wing2d;
        public ModelRenderer wing3;
        public ModelRenderer wing3b;
        public ModelRenderer wing3c;
        public ModelRenderer wing3d;
        public ModelRenderer wing4;
        public ModelRenderer wing4b;
        public ModelRenderer wing4c;
        public ModelRenderer wing4d;

        public Wing() {
            this.textureWidth = 64;
            this.textureHeight = 32;

            this.Centersquare = new ModelRenderer(this, 0, 6);
            this.Centersquare.setRotationPoint(0.0F, 0.0F, 0.0F);
            this.Centersquare.addBox(0.0F, 0.0F, 0.0F, 8, 1, 8);
            this.wing1 = new ModelRenderer(this, 0, 4);
            this.wing1.setRotationPoint(1.0F, 0.0F, -1.0F);
            this.wing1.addBox(0.0F, 0.0F, 0.0F, 7, 1, 1);
            this.Centersquare.addChild(this.wing1);
            this.wing1b = new ModelRenderer(this, 0, 2);
            this.wing1b.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing1b.addBox(0.0F, 0.0F, 0.0F, 5, 1, 1);
            this.wing1.addChild(this.wing1b);
            this.wing1c = new ModelRenderer(this, 0, 0);
            this.wing1c.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing1c.addBox(0.0F, 0.0F, 0.0F, 3, 1, 1);
            this.wing1b.addChild(this.wing1c);
            this.wing1d = new ModelRenderer(this, 0, 15);
            this.wing1d.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing1d.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
            this.wing1c.addChild(this.wing1d);
            this.wing2 = new ModelRenderer(this, 0, 4);
            this.wing2.setRotationPoint(9.0F, 0.0F, 1.0F);
            this.wing2.addBox(0.0F, 0.0F, 0.0F, 7, 1, 1);
            this.setRotationAngles(this.wing2, 0.0F, -1.5707963267948966F, 0.0F);
            this.Centersquare.addChild(this.wing2);
            this.wing2b = new ModelRenderer(this, 0, 2);
            this.wing2b.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing2b.addBox(0.0F, 0.0F, 0.0F, 5, 1, 1);
            this.wing2.addChild(this.wing2b);
            this.wing2c = new ModelRenderer(this, 0, 0);
            this.wing2c.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing2c.addBox(0.0F, 0.0F, 0.0F, 3, 1, 1);
            this.wing2b.addChild(this.wing2c);
            this.wing2d = new ModelRenderer(this, 0, 15);
            this.wing2d.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing2d.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
            this.wing2c.addChild(this.wing2d);
            this.wing3 = new ModelRenderer(this, 0, 4);
            this.wing3.setRotationPoint(7.0F, 0.0F, 9.0F);
            this.wing3.addBox(0.0F, 0.0F, 0.0F, 7, 1, 1);
            this.setRotationAngles(this.wing3, 0.0F, 3.141592653589793F, 0.0F);
            this.Centersquare.addChild(this.wing3);
            this.wing3b = new ModelRenderer(this, 0, 2);
            this.wing3b.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing3b.addBox(0.0F, 0.0F, 0.0F, 5, 1, 1);
            this.wing3.addChild(this.wing3b);
            this.wing3c = new ModelRenderer(this, 0, 0);
            this.wing3c.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing3c.addBox(0.0F, 0.0F, 0.0F, 3, 1, 1);
            this.wing3b.addChild(this.wing3c);
            this.wing3d = new ModelRenderer(this, 0, 15);
            this.wing3d.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing3d.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
            this.wing3c.addChild(this.wing3d);
            this.wing4 = new ModelRenderer(this, 0, 4);
            this.wing4.setRotationPoint(-1.0F, 0.0F, 7.0F);
            this.wing4.addBox(0.0F, 0.0F, 0.0F, 7, 1, 1);
            this.setRotationAngles(this.wing4, 0.0F, 1.5707963267948966F, 0.0F);
            this.Centersquare.addChild(this.wing4);
            this.wing4b = new ModelRenderer(this, 0, 2);
            this.wing4b.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing4b.addBox(0.0F, 0.0F, 0.0F, 5, 1, 1);
            this.wing4.addChild(this.wing4b);
            this.wing4c = new ModelRenderer(this, 0, 0);
            this.wing4c.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing4c.addBox(0.0F, 0.0F, 0.0F, 3, 1, 1);
            this.wing4b.addChild(this.wing4c);
            this.wing4d = new ModelRenderer(this, 0, 15);
            this.wing4d.setRotationPoint(2.0F, 0.0F, -1.0F);
            this.wing4d.addBox(0.0F, 0.0F, 0.0F, 1, 1, 1);
            this.wing4c.addChild(this.wing4d);
        }

        @Override
        public void render(Entity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float rotationYaw, float rotationPitch, float scale) {
            GlStateManager.enableBlend();
            GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
            GlStateManager.color(1.0F, 1.0F, 1.0F, 0.0F);
            this.Centersquare.render(scale);
            GlStateManager.disableBlend();
        }

        public void setRotationAngles(ModelRenderer modelRenderer, float x, float y, float z) {
            modelRenderer.rotateAngleX = x;
            modelRenderer.rotateAngleY = y;
            modelRenderer.rotateAngleZ = z;
        }
}

 

 

Edit: For the item model in hand I believe you're going to have to create the same model in JSON, I'm not sure if you can directly translate an ModelBase to items.

 

 

According to This post by Choonster it's not really possible if you want any longevity to the method. Since rendering the ModelBase with a TESR is deprecated. The best way is probably to use the program linked there to convert your Java into Json. Unless you want to do it by hand. Which is possible as well. 

 

Edit Edit: According to the post below it it might be possible. but I'm keeping the text here because it might be usefull later on.

Edited September 18, 2017 by oldcheese
The second part.

[Draco18s]

15 minutes ago, signat said:

Thank you, Draco! This makes perfect sense. Do you have a suggestion of a model class I can reference to try and figure out what I need to change? I looked around for something that might be rendering my item model (like when its held in hand) but didn't see it.

You have to get the baked model for it. I know I've seen posts about it here, but I can't find them now.

You're looking for "item quads" "render item on block" "baked quads" etc. with respect to 1.10 and newer and without a TESR.

[signat]

1 hour ago, oldcheese said:

The only thing you'd have to change is your amount of boxes. You'd probably want a box for the center, then a few rectangles to make the wings. 

 

If you don't feel like writing about twenty boxes I suggest using Qubble

 

which doesn't work that great, but is better than nothing.

 

Ofcourse there's a lot of other box-based modellers that you can use. or you can do it by hand for simple structures. I've made the following  star in about five minutes or so.  And as you can see it's model would take quite a while to code by hand: 

 

 

I really like the idea of building the model out of boxes and just coloring each box to match the item texture I was originally using. I don't see how to assign color after something like:

 

this.renderer.addbox()

 

but, I will try and find some reference material on how to build the model this way since its a relatively simple one.

 

Thanks for all your help!

 

 

[signat]

Thank you both for all your help. I also like the idea of creating a using a baked model. I am familiar with the process somewhat from using Unity, but this is obviously quite different. Rather than posting a lot of ignorant questions from this point on, I will just try and do some research on creating baked models for minecraft.

 

Thanks again!