コード例 #1
0
 public static void setup(TextureAtlasSprite icon) {
   if (!fboSupported) {
     return;
   }
   String name = IconAPI.getIconName(icon).replaceFirst("^minecraft:items/", "");
   if (icon instanceof TextureClock && name.equals("compass")) { // 1.5 bug
     name = "clock";
   }
   if ("compass".equals(name)) {
     if (!enableCompass) {
       return;
     }
   } else if ("clock".equals(name)) {
     if (!enableClock) {
       return;
     }
   } else {
     logger.warning("ignoring custom animation for %s not compass or clock", name);
     return;
   }
   ResourceLocation resource =
       TexturePackAPI.newMCPatcherResourceLocation(
           "/misc/" + name + ".properties", "dial/" + name + ".properties");
   if (TexturePackAPI.hasResource(resource)) {
     logger.fine("found custom %s (%s)", name, resource);
     setupInfo.put(icon, resource);
     active = true;
   }
 }
コード例 #2
0
 Layer newLayer(PropertiesFile properties, String suffix) {
   ResourceLocation textureResource = properties.getResourceLocation("source" + suffix, "");
   if (textureResource == null) {
     return null;
   }
   if (!TexturePackAPI.hasResource(textureResource)) {
     properties.error("could not read %s", textureResource);
     return null;
   }
   float scaleX = properties.getFloat("scaleX" + suffix, 1.0f);
   float scaleY = properties.getFloat("scaleY" + suffix, 1.0f);
   float offsetX = properties.getFloat("offsetX" + suffix, 0.0f);
   float offsetY = properties.getFloat("offsetY" + suffix, 0.0f);
   float angleMultiplier = properties.getFloat("rotationSpeed" + suffix, 0.0f);
   float angleOffset = properties.getFloat("rotationOffset" + suffix, 0.0f);
   String blend = properties.getString("blend" + suffix, "alpha");
   BlendMethod blendMethod = BlendMethod.parse(blend);
   if (blendMethod == null) {
     properties.error("unknown blend method %s", blend);
     return null;
   }
   boolean debug = properties.getBoolean("debug" + suffix, false);
   return new Layer(
       textureResource,
       scaleX,
       scaleY,
       offsetX,
       offsetY,
       angleMultiplier,
       angleOffset,
       blendMethod,
       debug);
 }
コード例 #3
0
 static void registerAnimations() {
   TextureObject texture = TexturePackAPI.getTextureObject(TexturePackAPI.ITEMS_PNG);
   if (texture instanceof TextureAtlas) {
     List<TextureAtlasSprite> animations = ((TextureAtlas) texture).animations;
     for (FancyDial instance : instances.values()) {
       instance.registerAnimation(animations);
     }
   }
 }
コード例 #4
0
  private FancyDial(TextureAtlasSprite icon, PropertiesFile properties) {
    this.icon = icon;
    this.properties = properties;
    name = IconAPI.getIconName(icon);
    x0 = IconAPI.getIconX0(icon);
    y0 = IconAPI.getIconY0(icon);
    width = IconAPI.getIconWidth(icon);
    height = IconAPI.getIconHeight(icon);
    scratchBuffer = ByteBuffer.allocateDirect(4 * width * height);

    int itemsTexture = TexturePackAPI.getTextureIfLoaded(TexturePackAPI.ITEMS_PNG);
    if (itemsTexture < 0) {
      logger.severe("could not get items texture");
      return;
    }
    itemsFBO = new FBO(itemsTexture, x0, y0, width, height);

    if (useScratchTexture) {
      logger.fine("rendering %s to %dx%d scratch texture", name, width, height);
      for (int i = 0; i < scratchFBO.length; i++) {
        scratchFBO[i] = new FBO(width, height);
      }
    } else {
      logger.fine("rendering %s directly to atlas", name);
    }

    boolean debug = false;
    for (int i = 0; ; i++) {
      Layer layer = newLayer(properties, "." + i);
      if (layer == null) {
        if (i > 0) {
          break;
        }
        continue;
      }
      layers.add(layer);
      debug |= layer.debug;
      logger.fine("  new %s", layer);
    }
    keyboard = new InputHandler(name, debug);
    if (layers.size() < 2) {
      logger.error("custom %s needs at least two layers defined", name);
      return;
    }

    outputFrames = properties.getInt("outputFrames", 0);

    int glError = GL11.glGetError();
    if (glError != 0) {
      logger.severe("%s during %s setup", GLU.gluErrorString(glError), name);
      return;
    }
    ok = true;
  }
コード例 #5
0
 public static boolean renderEnchantments3D(RenderItemCustom renderItem, IModel model) {
   if (currentItem != null) {
     EnchantmentList enchantments = CITUtils.findEnchantments(currentItem);
     if (!enchantments.isEmpty()) {
       renderingEnchantment = true;
       Enchantment.beginOuter3D();
       for (int i = 0; i < enchantments.size(); i++) {
         Enchantment enchantment = enchantments.getEnchantment(i);
         float intensity = enchantments.getIntensity(i);
         if (intensity > 0.0f && enchantment.bindTexture(null)) {
           enchantment.begin(intensity);
           renderItem.renderItem1(model, -1, null);
           enchantment.end();
         }
       }
       Enchantment.endOuter3D();
       TexturePackAPI.bindTexture(TexturePackAPI.ITEMS_PNG);
       renderingEnchantment = false;
     }
   }
   return !CITUtils.useGlint;
 }
コード例 #6
0
 private void renderImpl(double angle) {
   for (Layer layer : layers) {
     layer.blendMethod.applyBlending();
     GL11.glPushMatrix();
     TexturePackAPI.bindTexture(layer.textureName);
     float offsetX = layer.offsetX;
     float offsetY = layer.offsetY;
     float scaleX = layer.scaleX;
     float scaleY = layer.scaleY;
     if (layer.debug) {
       offsetX += offsetXDelta;
       offsetY += offsetYDelta;
       scaleX += scaleXDelta;
       scaleY += scaleYDelta;
     }
     GL11.glTranslatef(offsetX, offsetY, 0.0f);
     GL11.glScalef(scaleX, scaleY, 1.0f);
     float layerAngle = (float) (angle * layer.rotationMultiplier + layer.rotationOffset);
     GL11.glRotatef(layerAngle, 0.0f, 0.0f, 1.0f);
     GL11.glCallList(drawList);
     GL11.glPopMatrix();
   }
 }
コード例 #7
0
public class ColorizeBlock18 {
  private static final MCLogger logger = MCLogger.getLogger(MCPatcherUtils.CUSTOM_COLORS);

  private static final ResourceLocation COLOR_PROPERTIES =
      TexturePackAPI.newMCPatcherResourceLocation("color.properties");

  private static Block grassBlock;
  private static Block mycelBlock;

  private final CTMUtils18 ctm;
  private boolean useCM;
  private IColorMap colorMap;
  private boolean isSmooth;
  private final float[][] vertexColors = new float[4][3];
  public final float[] vertexColor = new float[3];

  private static final int[][][] FACE_VERTICES =
      new int[][][] {
        // bottom face (y=0)
        {
          {0, 0, 1}, // top left
          {0, 0, 0}, // bottom left
          {1, 0, 0}, // bottom right
          {1, 0, 1}, // top right
        },
        // top face (y=1)
        {
          {0, 1, 0},
          {0, 1, 1},
          {1, 1, 1},
          {1, 1, 0},
        },
        // north face (z=0)
        {
          {1, 1, 0},
          {1, 0, 0},
          {0, 0, 0},
          {0, 1, 0},
        },
        // south face (z=1)
        {
          {0, 1, 1},
          {0, 0, 1},
          {1, 0, 1},
          {1, 1, 1},
        },
        // west face (x=0)
        {
          {0, 1, 0},
          {0, 0, 0},
          {0, 0, 1},
          {0, 1, 1},
        },
        // east face (x=1)
        {
          {1, 1, 1},
          {1, 0, 1},
          {1, 0, 0},
          {1, 1, 0},
        }
      };

  private static final int[][][] FACE_VERTICES_WATER =
      new int[][][] {
        // bottom face (y=0)
        {
          {0, 0, 1}, // top left
          {0, 0, 0}, // bottom left
          {1, 0, 0}, // bottom right
          {1, 0, 1}, // top right
        },
        // top face (y=1)
        {
          {0, 1, 0},
          {0, 1, 1},
          {1, 1, 1},
          {1, 1, 0},
        },
        // north face (z=0)
        {
          {0, 1, 0},
          {1, 1, 0},
          {1, 0, 0},
          {0, 0, 0},
        },
        // south face (z=1)
        {
          {1, 1, 1},
          {0, 1, 1},
          {0, 0, 1},
          {1, 0, 1},
        },
        // west face (x=0)
        {
          {0, 1, 1},
          {0, 1, 0},
          {0, 0, 0},
          {0, 0, 1},
        },
        // east face (x=1)
        {
          {1, 1, 0},
          {1, 1, 1},
          {1, 0, 1},
          {1, 0, 0},
        }
      };

  static {
    TexturePackChangeHandler.register(
        new TexturePackChangeHandler(MCPatcherUtils.CUSTOM_COLORS, 2) {
          @Override
          public void beforeChange() {
            reset();
          }

          @Override
          public void afterChange() {
            PropertiesFile properties = PropertiesFile.getNonNull(logger, COLOR_PROPERTIES);
            ColorizeBlock.reloadAll(properties);
          }
        });
  }

  public static void reset() {
    try {
      grassBlock = BlockAPI.getFixedBlock("minecraft:grass");
      mycelBlock = BlockAPI.getFixedBlock("minecraft:mycelium");
      ColorizeBlock.reset();
    } catch (Throwable e) {
      e.printStackTrace();
    }
  }

  public ColorizeBlock18(CTMUtils18 ctm) {
    this.ctm = ctm;
  }

  public void preRender(
      IBlockAccess blockAccess,
      IModel model,
      IBlockState blockState,
      Position position,
      Block block,
      boolean useAO) {
    colorMap = null;
    useCM = RenderPassAPI.instance.useColorMultiplierThisPass(block);
    if (useCM) {
      List<BlockStateMatcher> maps = ColorizeBlock.findColorMaps(block);
      if (maps != null) {
        for (BlockStateMatcher matcher : maps) {
          if (matcher.matchBlockState(blockState)) {
            colorMap = ColorizeBlock.getThreadLocal(matcher);
            break;
          }
        }
      }
    }
    isSmooth = false;
  }

  public void preRenderHeld(IModel model, IBlockState blockState, Block block) {
    colorMap = null;
    isSmooth = false;
    List<BlockStateMatcher> maps = ColorizeBlock.findColorMaps(block);
    if (maps != null) {
      for (BlockStateMatcher matcher : maps) {
        if (matcher.matchBlockState(blockState)) {
          colorMap = ColorizeBlock.getThreadLocal(matcher);
          break;
        }
      }
    }
  }

  public void clear() {
    colorMap = null;
    isSmooth = false;
  }

  public void setDirection(Direction direction) {
    setDirection(direction, FACE_VERTICES);
  }

  public void setDirectionWater(Direction direction) {
    setDirection(direction, FACE_VERTICES_WATER);
  }

  private void setDirection(Direction direction, int[][][] faceVertices) {
    if (ColorizeBlock.enableSmoothBiomes
        && direction != null
        && colorMap != null
        && ctm.isInWorld()) {
      isSmooth = true;
      int[][] offsets = faceVertices[direction.ordinal()];
      computeVertexColor(offsets[0], vertexColors[0]);
      computeVertexColor(offsets[1], vertexColors[1]);
      computeVertexColor(offsets[2], vertexColors[2]);
      computeVertexColor(offsets[3], vertexColors[3]);
    } else {
      isSmooth = false;
    }
  }

  private void computeVertexColor(int[] offsets, float[] color) {
    int i = ctm.getI() + offsets[0];
    int j = ctm.getJ() + offsets[1];
    int k = ctm.getK() + offsets[2];
    if (ColorizeBlock.enableTestColorSmoothing) {
      int rgb = 0;
      if (i % 2 == 0) {
        rgb |= 0xff0000;
      }
      if (j % 2 == 0) {
        rgb |= 0x00ff00;
      }
      if (k % 2 == 0) {
        rgb |= 0x0000ff;
      }
      ColorUtils.intToFloat3(rgb, color);
    } else {
      float[] tmp = colorMap.getColorMultiplierF(ctm.getBlockAccess(), i, j, k);
      color[0] = tmp[0];
      color[1] = tmp[1];
      color[2] = tmp[2];
    }
  }

  public boolean useColormap(ModelFace face) {
    return useCM
        && (face.useColormap()
            || (colorMap != null && ctm.getBlock() != grassBlock && ctm.getBlock() != mycelBlock));
  }

  public int colorMultiplier(int color) {
    if (colorMap == null) {
      return color;
    } else if (ctm.isInWorld()) {
      return colorMap.getColorMultiplier(ctm.getBlockAccess(), ctm.getI(), ctm.getJ(), ctm.getK());
    } else {
      return colorMap.getColorMultiplier();
    }
  }

  public float getVertexColor(float color, int vertex, int channel) {
    if (isSmooth) {
      return vertexColors[vertex][channel];
    } else {
      return color;
    }
  }

  public void applyVertexColor(Tessellator tessellator, float base, int vertex) {
    if (isSmooth) {
      float[] rgb = vertexColors[vertex];
      TessellatorAPI.setColorOpaque_F(tessellator, base * rgb[0], base * rgb[1], base * rgb[2]);
    }
  }

  public float applyVertexColor(float base, int vertex, float r, float g, float b) {
    if (isSmooth) {
      float[] rgb = vertexColors[vertex];
      vertexColor[0] = base * rgb[0];
      vertexColor[1] = base * rgb[1];
      vertexColor[2] = base * rgb[2];
    } else {
      vertexColor[0] = r;
      vertexColor[1] = g;
      vertexColor[2] = b;
    }
    return vertexColor[0];
  }

  public float getVertexColor(int index) {
    return vertexColor[index];
  }

  public int getParticleColor(
      IBlockAccess blockAccess, IBlockState blockState, Position position, int defaultColor) {
    return getColorMultiplier(blockAccess, blockState, position, defaultColor);
  }

  // public static methods requested by MamiyaOtaru for VoxelMap
  public static int getColorMultiplier(
      IBlockAccess blockAccess, IBlockState blockState, Position position, int defaultColor) {
    List<BlockStateMatcher> maps = ColorizeBlock.findColorMaps(blockState.getBlock());
    if (maps != null) {
      for (BlockStateMatcher matcher : maps) {
        if (matcher.matchBlockState(blockState)) {
          IColorMap colorMap = ColorizeBlock.getThreadLocal(matcher);
          return colorMap.getColorMultiplier(
              blockAccess, position.getI(), position.getJ(), position.getK());
        }
      }
    }
    return defaultColor;
  }

  public static int getColorMultiplier(
      IBlockAccess blockAccess, IBlockState blockState, Position position) {
    return getColorMultiplier(blockAccess, blockState, position, 0xffffff);
  }
}