use of logisticspipes.proxy.object3d.interfaces.TextureTransformation in project LogisticsPipes by RS485.
the class ThermalDynamicsProxy method renderPipeConnections.
@Override
@SideOnly(Side.CLIENT)
public void renderPipeConnections(LogisticsTileGenericPipe pipeTile, List<RenderEntry> renderList) {
for (EnumFacing dir : EnumFacing.VALUES) {
if (pipeTile.renderState.pipeConnectionMatrix.isTDConnected(dir)) {
TextureTransformation texture = connectionTextureBasic;
if (pipeTile.renderState.textureMatrix.isRouted()) {
if (pipeTile.renderState.textureMatrix.isRoutedInDir(dir)) {
texture = connectionTextureActive;
} else {
texture = connectionTextureInactive;
}
}
double move = 0.25;
LPTranslation localTranslation = new LPTranslation(0.5D + dir.getDirectionVec().getX() * move, 0.5D + dir.getDirectionVec().getY() * move, 0.5D + dir.getDirectionVec().getZ() * move);
renderList.add(new RenderEntry(SimpleServiceLocator.cclProxy.wrapModel(RenderDuct.modelConnection[2][dir.ordinal()]), localTranslation, texture));
}
}
}
use of logisticspipes.proxy.object3d.interfaces.TextureTransformation in project LogisticsPipes by RS485.
the class ProxyManager method load.
public static void load() {
// @formatter:off
// CHECKSTYLE:OFF
SimpleServiceLocator.setBuildCraftProxy(ProxyManager.getWrappedProxy(LPConstants.bcTransportModID + "+" + LPConstants.bcSiliconModID, IBCProxy.class, BuildCraftProxy.class, new IBCProxy() {
@Override
public void registerPipeInformationProvider() {
}
@Override
public void initProxy() {
}
@Override
public boolean isActive() {
return false;
}
@Override
public boolean isInstalled() {
return false;
}
@Override
public CraftingParts getRecipeParts() {
return null;
}
@Override
public void addCraftingRecipes(CraftingParts parts) {
}
@Override
public Class<? extends ICraftingRecipeProvider> getAssemblyTableProviderClass() {
return null;
}
@Override
public void registerInventoryHandler() {
}
@Override
public IBCPipeCapabilityProvider getIBCPipeCapabilityProvider(LogisticsTileGenericPipe pipe) {
return new IBCPipeCapabilityProvider() {
@Override
public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
return false;
}
@Nullable
@Override
public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
return null;
}
};
}
@Override
public Object createMjReceiver(@Nonnull LogisticsPowerJunctionTileEntity te) {
return null;
}
@Override
public boolean isBuildCraftPipe(TileEntity tile) {
return false;
}
}, IBCPipeCapabilityProvider.class));
SimpleServiceLocator.setElectricItemProxy(ProxyManager.getWrappedProxy(LPConstants.ic2ModID, IIC2Proxy.class, IC2Proxy.class, new IIC2Proxy() {
@Override
public void addCraftingRecipes(CraftingParts parts) {
}
@Override
public boolean hasIC2() {
return false;
}
@Override
public void registerToEneryNet(TileEntity tile) {
}
@Override
public void unregisterToEneryNet(TileEntity tile) {
}
@Override
public boolean acceptsEnergyFrom(TileEntity tile1, TileEntity tile2, EnumFacing opposite) {
return false;
}
@Override
public boolean isEnergySink(TileEntity tile) {
return false;
}
@Override
public double demandedEnergyUnits(TileEntity tile) {
return 0;
}
@Override
public double injectEnergyUnits(TileEntity tile, EnumFacing opposite, double d) {
return d;
}
}));
SimpleServiceLocator.setCCProxy(ProxyManager.getWrappedProxy(LPConstants.computerCraftModID, ICCProxy.class, CCProxy.class, new ICCProxy() {
@Override
public boolean isTurtle(TileEntity tile) {
return false;
}
@Override
public boolean isComputer(TileEntity tile) {
return false;
}
@Override
public boolean isCC() {
return false;
}
@Override
public boolean isLuaThread(Thread thread) {
return false;
}
@Override
public void queueEvent(String event, Object[] arguments, LogisticsTileGenericPipe logisticsTileGenericPipe) {
}
@Override
public void setTurtleConnect(boolean flag, LogisticsTileGenericPipe logisticsTileGenericPipe) {
}
@Override
public boolean getTurtleConnect(LogisticsTileGenericPipe logisticsTileGenericPipe) {
return false;
}
@Override
public int getLastCCID(LogisticsTileGenericPipe logisticsTileGenericPipe) {
return 0;
}
@Override
public void handleMesssage(int computerId, Object message, LogisticsTileGenericPipe tile, int sourceId) {
}
@Override
public void addCraftingRecipes(CraftingParts parts) {
}
@Override
public Object getAnswer(Object object) {
return object;
}
}));
SimpleServiceLocator.setThermalExpansionProxy(ProxyManager.getWrappedProxy(LPConstants.thermalExpansionModID, IThermalExpansionProxy.class, ThermalExpansionProxy.class, new IThermalExpansionProxy() {
@Override
public boolean isTE() {
return false;
}
@Override
public CraftingParts getRecipeParts() {
return null;
}
@Override
public boolean isToolHammer(Item stack) {
return false;
}
@Override
public boolean canHammer(@Nonnull ItemStack stack, EntityPlayer entityplayer, BlockPos pos) {
return false;
}
@Override
public void toolUsed(@Nonnull ItemStack stack, EntityPlayer entityplayer, BlockPos pos) {
}
}));
SimpleServiceLocator.setBetterStorageProxy(ProxyManager.getWrappedProxy(LPConstants.betterStorageModID, IBetterStorageProxy.class, BetterStorageProxy.class, new IBetterStorageProxy() {
@Override
public boolean isBetterStorageCrate(TileEntity tile) {
return false;
}
@Override
public ICrateStorageProxy getCrateStorageProxy(TileEntity tile) {
return new ICrateStorageProxy() {
@Override
public Iterable<ItemStack> getContents() {
return null;
}
@Override
public int getUniqueItems() {
return 0;
}
@Override
public int getItemCount(@Nonnull ItemStack stack) {
return 0;
}
@Override
@Nonnull
public ItemStack extractItems(@Nonnull ItemStack stack, int count) {
return null;
}
@Override
public int getSpaceForItem(@Nonnull ItemStack stack) {
return 0;
}
@Override
@Nonnull
public ItemStack insertItems(@Nonnull ItemStack stack) {
return stack;
}
};
}
}, ICrateStorageProxy.class));
SimpleServiceLocator.setNEIProxy(ProxyManager.getWrappedProxy(LPConstants.neiModID, INEIProxy.class, null, /*NEIProxy.class*/
new INEIProxy() {
@Override
public List<String> getInfoForPosition(World world, EntityPlayer player, RayTraceResult objectMouseOver) {
return new ArrayList<>(0);
}
@Override
@SideOnly(Side.CLIENT)
public boolean renderItemToolTip(int posX, int posY, List<String> msg, TextFormatting rarityColor, @Nonnull ItemStack stack) {
return false;
}
@Override
@SideOnly(Side.CLIENT)
public List<String> getItemToolTip(@Nonnull ItemStack stack, EntityPlayer thePlayer, ITooltipFlag advancedItemTooltips, GuiContainer screen) {
return stack.getTooltip(thePlayer, advancedItemTooltips);
}
@Override
@Nonnull
public ItemStack getItemForPosition(World world, EntityPlayer player, RayTraceResult objectMouseOver) {
return null;
}
}));
SimpleServiceLocator.setFactorizationProxy(ProxyManager.getWrappedProxy(LPConstants.factorizationModID, IFactorizationProxy.class, FactorizationProxy.class, tile -> false));
SimpleServiceLocator.setEnderIOProxy(ProxyManager.getWrappedProxy(LPConstants.enderioModID, IEnderIOProxy.class, null, /*EnderIOProxy.class*/
new IEnderIOProxy() {
@Override
public boolean isSendAndReceive(TileEntity tile) {
return false;
}
@Override
public boolean isTransceiver(TileEntity tile) {
return false;
}
@Override
public List<TileEntity> getConnectedTransceivers(TileEntity tile) {
return null;
}
@Override
public boolean isEnderIO() {
return false;
}
@Override
public boolean isItemConduit(TileEntity tile, EnumFacing dir) {
return false;
}
@Override
public boolean isFluidConduit(TileEntity tile, EnumFacing dir) {
return false;
}
@Override
public boolean isBundledPipe(TileEntity tile) {
return false;
}
}));
SimpleServiceLocator.setIronChestProxy(ProxyManager.getWrappedProxy(LPConstants.ironChestModID, IIronChestProxy.class, IronChestProxy.class, new IIronChestProxy() {
@Override
public boolean isIronChest(TileEntity tile) {
return false;
}
@Override
@SideOnly(Side.CLIENT)
public boolean isChestGui(GuiScreen gui) {
return false;
}
}));
SimpleServiceLocator.setEnderStorageProxy(ProxyManager.getWrappedProxy("enderstorage", IEnderStorageProxy.class, EnderStorageProxy.class, new IEnderStorageProxy() {
@Override
public boolean isEnderChestBlock(Block block) {
return false;
}
@Override
public void openEnderChest(World world, int x, int y, int z, EntityPlayer player) {
}
}));
SimpleServiceLocator.setOpenComputersProxy(ProxyManager.getWrappedProxy(LPConstants.openComputersModID, IOpenComputersProxy.class, OpenComputersProxy.class, new IOpenComputersProxy() {
@Override
public void initLogisticsTileGenericPipe(LogisticsTileGenericPipe tile) {
}
@Override
public void initLogisticsSolidTileEntity(LogisticsSolidTileEntity tile) {
}
@Override
public void handleWriteToNBT(IOCTile tile, NBTTagCompound nbt) {
}
@Override
public void handleReadFromNBT(IOCTile tile, NBTTagCompound nbt) {
}
@Override
public void handleInvalidate(IOCTile tile) {
}
@Override
public void handleChunkUnload(IOCTile tile) {
}
@Override
public void addToNetwork(TileEntity tile) {
}
}));
/* SimpleServiceLocator.setToolWrenchProxy(ProxyManager.getWrappedProxy("!IToolWrench", IToolWrenchProxy.class, ToolWrenchProxy.class, new IToolWrenchProxy() {
@Override public void wrenchUsed(EntityPlayer entityplayer, int x, int y, int z) {}
@Override public boolean isWrenchEquipped(EntityPlayer entityplayer) {return false;}
@Override public boolean canWrench(EntityPlayer entityplayer, int x, int y, int z) {return false;}
@Override public boolean isWrench(Item item) {return false;}
}));*/
SimpleServiceLocator.setThermalDynamicsProxy(ProxyManager.getWrappedProxy(LPConstants.thermalDynamicsModID, ITDProxy.class, ThermalDynamicsProxy.class, new ITDProxy() {
@Override
public ITDPart getTDPart(final LogisticsTileGenericPipe pipe) {
return new ITDPart() {
@Override
public TileEntity getInternalDuct() {
return pipe;
}
@Override
public void setWorld_LP(World world) {
}
@Override
public void invalidate() {
}
@Override
public void onChunkUnload() {
}
@Override
public void scheduleNeighborChange() {
}
@Override
public void connectionsChanged() {
}
@Override
public boolean isLPSideBlocked(int i) {
return false;
}
@Override
public void setPos(BlockPos pos) {
}
};
}
@Override
public boolean isActive() {
return false;
}
@Override
public void registerPipeInformationProvider() {
}
@Override
public boolean isItemDuct(TileEntity tile) {
return false;
}
@Override
@SideOnly(Side.CLIENT)
public void renderPipeConnections(LogisticsTileGenericPipe pipeTile, List<RenderEntry> list) {
}
@Override
public void registerTextures(TextureMap iconRegister) {
}
@Override
public boolean isBlockedSide(TileEntity with, EnumFacing opposite) {
return false;
}
}, ITDPart.class));
SimpleServiceLocator.setMCMPProxy(ProxyManager.getWrappedProxy(LPConstants.mcmpModID, IMCMPProxy.class, MCMPProxy.class, new IMCMPProxy() {
@Override
public IMCMPLTGPCompanion createMCMPCompanionFor(LogisticsTileGenericPipe pipe) {
return new IMCMPLTGPCompanion() {
@Override
public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
return false;
}
@Nullable
@Override
public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
return null;
}
@Override
public NBTTagCompound getUpdateTag() {
return new NBTTagCompound();
}
@Override
public void handleUpdateTag(NBTTagCompound tag) {
}
@Override
public TileEntity getMCMPTileEntity() {
return null;
}
@Override
public void update() {
}
};
}
@Override
public IMCMPBlockAccess createMCMPBlockAccess() {
return new IMCMPBlockAccess() {
@Override
public void addBlockState(BlockStateContainer.Builder builder) {
}
@Override
public IBlockState getExtendedState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
return state;
}
@Override
public void addCollisionBoxToList(IBlockState state, World world, BlockPos pos, AxisAlignedBB entityBox, List<AxisAlignedBB> collidingBoxes, Entity entity, boolean isActualState) {
}
@Override
public RayTraceResult collisionRayTrace(IBlockState state, World world, BlockPos pos, Vec3d start, Vec3d end) {
return null;
}
@Override
public Block getBlock() {
return null;
}
@Override
public void addDrops(NonNullList<ItemStack> list, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
}
};
}
@Override
public void addQuads(@Nonnull List<BakedQuad> list, IBlockState state, EnumFacing side, long rand) {
}
@Override
public void registerTileEntities() {
}
@Override
public boolean checkIntersectionWith(LogisticsTileGenericPipe logisticsTileGenericPipe, AxisAlignedBB aabb) {
return false;
}
@Override
public boolean hasParts(LogisticsTileGenericPipe pipeTile) {
return false;
}
@Override
@SideOnly(Side.CLIENT)
public void renderTileEntitySpecialRenderer(LogisticsTileGenericPipe tileentity, double x, double y, double z, float partialTicks, int destroyStage, float alpha) {
}
}, IMCMPLTGPCompanion.class));
final IBounds dummyBounds = new IBounds() {
@Override
public IVec3 min() {
return new IVec3() {
@Override
public double x() {
return 0;
}
@Override
public double y() {
return 0;
}
@Override
public double z() {
return 0;
}
@Override
public Object getOriginal() {
return null;
}
};
}
@Override
public IVec3 max() {
return new IVec3() {
@Override
public double x() {
return 0;
}
@Override
public double y() {
return 0;
}
@Override
public double z() {
return 0;
}
@Override
public Object getOriginal() {
return null;
}
};
}
@Override
public AxisAlignedBB toAABB() {
return null;
}
};
final IModel3D dummy3DModel = new IModel3D() {
@Override
public IModel3D backfacedCopy() {
return this;
}
@Override
public void render(I3DOperation... i3dOperations) {
}
@Override
public List<BakedQuad> renderToQuads(VertexFormat format, I3DOperation... i3dOperations) {
return Lists.newArrayList();
}
@Override
public void computeNormals() {
}
@Override
public void computeStandardLighting() {
}
@Override
public IBounds bounds() {
return dummyBounds;
}
@Override
public IModel3D apply(I3DOperation translation) {
return this;
}
@Override
public IModel3D copy() {
return this;
}
@Override
public IModel3D twoFacedCopy() {
return this;
}
@Override
public Object getOriginal() {
return this;
}
@Override
public IBounds getBoundsInside(AxisAlignedBB boundingBox) {
return dummyBounds;
}
};
ICCLProxy dummyCCLProxy = new ICCLProxy() {
@SideOnly(Side.CLIENT)
@Override
public TextureTransformation createIconTransformer(TextureAtlasSprite registerIcon) {
return new TextureTransformation() {
@Override
public Object getOriginal() {
return null;
}
@Override
public void update(TextureAtlasSprite registerIcon) {
}
@Override
public TextureAtlasSprite getTexture() {
return null;
}
};
}
@Override
public IRenderState getRenderState() {
return new IRenderState() {
@Override
public void reset() {
}
@Override
public void setAlphaOverride(int i) {
}
@Override
public void draw() {
}
@Override
public void setBrightness(IBlockAccess world, BlockPos pos) {
}
@Override
public void startDrawing(int mode, VertexFormat format) {
}
};
}
@Override
public Map<String, IModel3D> parseObjModels(InputStream resourceAsStream, int i, LPScale scale) {
return new HashMap<>();
}
@Override
public Object getRotation(int i, int j) {
return null;
}
@Override
public Object getScale(double d, double e, double f) {
return null;
}
@Override
public Object getScale(double d) {
return null;
}
@Override
public ITranslation getTranslation(double d, double e, double f) {
return new ITranslation() {
@Override
public ITranslation inverse() {
return this;
}
@Override
public Object getOriginal() {
return null;
}
};
}
@Override
public ITranslation getTranslation(IVec3 min) {
return new ITranslation() {
@Override
public ITranslation inverse() {
return this;
}
@Override
public Object getOriginal() {
return null;
}
};
}
@Override
public Object getUVScale(double i, double d) {
return null;
}
@Override
public Object getUVTranslation(float i, float f) {
return null;
}
@Override
public Object getUVTransformationList(I3DOperation[] uvTranslation) {
return null;
}
@Override
public IModel3D wrapModel(Object model) {
return dummy3DModel;
}
@Override
public boolean isActivated() {
return false;
}
@Override
public Object getRotation(double d, int i, int j, int k) {
return null;
}
@Override
public IModel3D combine(Collection<IModel3D> list) {
return dummy3DModel;
}
@Override
public Object getColourMultiplier(int i) {
return null;
}
@Override
public IModelState getDefaultBlockState() {
return null;
}
};
// @formatter:on
// CHECKSTYLE:ON
Class<?>[] cclSubWrapper = new Class<?>[] { TextureTransformation.class, IRenderState.class, IModel3D.class, ITranslation.class, IVec3.class, IBounds.class };
SimpleServiceLocator.setCCLProxy(ProxyManager.getWrappedProxy("!" + LPConstants.cclrenderModID, ICCLProxy.class, CCLProxy.class, dummyCCLProxy, cclSubWrapper));
SimpleServiceLocator.setConfigToolHandler(new ConfigToolHandler());
SimpleServiceLocator.configToolHandler.registerWrapper();
SimpleServiceLocator.setPowerProxy(new PowerProxy());
}
use of logisticspipes.proxy.object3d.interfaces.TextureTransformation in project LogisticsPipes by RS485.
the class LogisticsNewRenderPipe method fillObjectsToRenderList.
private static void fillObjectsToRenderList(List<RenderEntry> objectsToRender, LogisticsTileGenericPipe pipeTile, PipeRenderState renderState) {
List<Edge> edgesToRender = new ArrayList<>(Arrays.asList(Edge.values()));
Map<Corner, Integer> connectionAtCorner = new HashMap<>();
List<PipeMount> mountCanidates = new ArrayList<>(Arrays.asList(PipeMount.values()));
int connectionCount = 0;
for (EnumFacing dir : EnumFacing.VALUES) {
if (renderState.pipeConnectionMatrix.isConnected(dir) || pipeTile.pipe.hasSpecialPipeEndAt(dir)) {
connectionCount++;
if (renderState.pipeConnectionMatrix.isTDConnected(dir) || renderState.pipeConnectionMatrix.isBCConnected(dir)) {
I3DOperation[] texture = new I3DOperation[] { LogisticsNewRenderPipe.basicPipeTexture };
if (renderState.textureMatrix.isRouted()) {
if (renderState.textureMatrix.isRoutedInDir(dir)) {
if (renderState.textureMatrix.isSubPowerInDir(dir)) {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(0, +23F / 100), LogisticsNewRenderPipe.statusBCTexture) };
} else {
texture = new I3DOperation[] { LogisticsNewRenderPipe.statusBCTexture };
}
} else {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(0, -23F / 100), LogisticsNewRenderPipe.statusBCTexture) };
}
}
for (IModel3D model : LogisticsNewRenderPipe.sideBC.get(dir)) {
objectsToRender.add(new RenderEntry(model, texture));
}
} else if (!pipeTile.pipe.hasSpecialPipeEndAt(dir)) {
I3DOperation[] texture = new I3DOperation[] { LogisticsNewRenderPipe.basicPipeTexture };
if (renderState.textureMatrix.isRouted()) {
if (renderState.textureMatrix.isRoutedInDir(dir)) {
if (renderState.textureMatrix.isSubPowerInDir(dir)) {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(-2.5F / 10, 0), LogisticsNewRenderPipe.statusTexture) };
} else {
texture = new I3DOperation[] { LogisticsNewRenderPipe.statusTexture };
}
} else {
if (renderState.textureMatrix.isHasPowerUpgrade()) {
if (renderState.textureMatrix.getPointedOrientation() == dir) {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(+2.5F / 10, 0), LogisticsNewRenderPipe.statusTexture) };
} else {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(-2.5F / 10, 37F / 100), LogisticsNewRenderPipe.statusTexture) };
}
} else {
if (renderState.textureMatrix.getPointedOrientation() == dir) {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(+2.5F / 10, 37F / 100), LogisticsNewRenderPipe.statusTexture) };
} else {
texture = new I3DOperation[] { new LPUVTransformationList(new LPUVTranslation(0, 37F / 100), LogisticsNewRenderPipe.statusTexture) };
}
}
}
}
for (IModel3D model : LogisticsNewRenderPipe.sideNormal.get(dir)) {
double[] bounds = { Block.FULL_BLOCK_AABB.minY, Block.FULL_BLOCK_AABB.minZ, Block.FULL_BLOCK_AABB.minX, Block.FULL_BLOCK_AABB.maxY, Block.FULL_BLOCK_AABB.maxZ, Block.FULL_BLOCK_AABB.maxX };
if (pipeTile.getWorld() != null) {
// This can be null in some cases now !!!
DoubleCoordinates coords = CoordinateUtils.add(new DoubleCoordinates((TileEntity) pipeTile), dir);
Block block = coords.getBlock(pipeTile.getWorld());
AxisAlignedBB bb = block.getCollisionBoundingBox(coords.getBlockState(pipeTile.getWorld()), pipeTile.getWorld(), coords.getBlockPos());
if (bb == null)
bb = Block.FULL_BLOCK_AABB;
bounds = new double[] { bb.minY, bb.minZ, bb.minX, bb.maxY, bb.maxZ, bb.maxX };
if (SimpleServiceLocator.enderIOProxy.isItemConduit(coords.getTileEntity(pipeTile.getWorld()), dir.getOpposite()) || SimpleServiceLocator.enderIOProxy.isFluidConduit(coords.getTileEntity(pipeTile.getWorld()), dir.getOpposite())) {
bounds = new double[] { 0.0249D, 0.0249D, 0.0249D, 0.9751D, 0.9751D, 0.9751D };
}
}
double bound = bounds[dir.ordinal() / 2 + (dir.ordinal() % 2 == 0 ? 3 : 0)];
ScaleObject key = new ScaleObject(model, bound);
IModel3D model2 = LogisticsNewRenderPipe.scaleMap.get(key);
if (model2 == null) {
model2 = model.copy();
IVec3 min = model2.bounds().min();
model2.apply(new LPTranslation(min).inverse());
double toAdd;
if (dir.ordinal() % 2 == 1) {
toAdd = 1 + (bound / LPConstants.PIPE_MIN_POS);
model2.apply(new LPScale(dir.getDirectionVec().getX() != 0 ? toAdd : 1, dir.getDirectionVec().getY() != 0 ? toAdd : 1, dir.getDirectionVec().getZ() != 0 ? toAdd : 1));
} else {
bound = 1 - bound;
toAdd = 1 + (bound / LPConstants.PIPE_MIN_POS);
model2.apply(new LPScale(dir.getDirectionVec().getX() != 0 ? toAdd : 1, dir.getDirectionVec().getY() != 0 ? toAdd : 1, dir.getDirectionVec().getZ() != 0 ? toAdd : 1));
model2.apply(new LPTranslation(dir.getDirectionVec().getX() * bound, dir.getDirectionVec().getY() * bound, dir.getDirectionVec().getZ() * bound));
}
model2.apply(new LPTranslation(min));
LogisticsNewRenderPipe.scaleMap.put(key, model2);
}
objectsToRender.add(new RenderEntry(model2, texture));
}
}
for (Edge edge : Edge.values()) {
if (edge.part1 == dir || edge.part2 == dir) {
edgesToRender.remove(edge);
for (PipeMount mount : PipeMount.values()) {
if ((mount.dir == edge.part1 && mount.side == edge.part2) || (mount.dir == edge.part2 && mount.side == edge.part1)) {
mountCanidates.remove(mount);
}
}
}
}
for (Corner corner : Corner.values()) {
if (corner.ew.dir == dir || corner.ns.dir == dir || corner.ud.dir == dir) {
if (!connectionAtCorner.containsKey(corner)) {
connectionAtCorner.put(corner, 1);
} else {
connectionAtCorner.put(corner, connectionAtCorner.get(corner) + 1);
}
}
}
}
}
for (Corner corner : Corner.values()) {
TextureTransformation cornerTexture = LogisticsNewRenderPipe.basicPipeTexture;
if (!renderState.textureMatrix.isHasPower() && renderState.textureMatrix.isRouted()) {
cornerTexture = LogisticsNewRenderPipe.inactiveTexture;
} else if (!renderState.textureMatrix.isRouted() && connectionCount > 2) {
cornerTexture = LogisticsNewRenderPipe.inactiveTexture;
}
int count = connectionAtCorner.containsKey(corner) ? connectionAtCorner.get(corner) : 0;
if (count == 0) {
for (IModel3D model : LogisticsNewRenderPipe.corners_M.get(corner)) {
objectsToRender.add(new RenderEntry(model, cornerTexture));
}
} else if (count == 1) {
for (PipeTurnCorner turn : PipeTurnCorner.values()) {
if (turn.corner != corner) {
continue;
}
if (renderState.pipeConnectionMatrix.isConnected(turn.getPointer()) || pipeTile.pipe.hasSpecialPipeEndAt(turn.getPointer())) {
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.spacers.get(turn), cornerTexture));
break;
}
}
} else if (count == 2) {
for (PipeTurnCorner turn : PipeTurnCorner.values()) {
if (turn.corner != corner) {
continue;
}
if (!renderState.pipeConnectionMatrix.isConnected(turn.getPointer()) || pipeTile.pipe.hasSpecialPipeEndAt(turn.getPointer())) {
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.corners_I.get(turn), cornerTexture));
break;
}
}
} else if (count == 3) {
for (IModel3D model : LogisticsNewRenderPipe.corners_I3.get(corner)) {
objectsToRender.add(new RenderEntry(model, cornerTexture));
}
}
}
edgesToRender.stream().map(edge -> new RenderEntry(LogisticsNewRenderPipe.edges.get(edge), LogisticsNewRenderPipe.basicPipeTexture)).forEach(objectsToRender::add);
for (int i = 0; i < 6; i += 2) {
EnumFacing dir = EnumFacing.getFront(i);
List<EnumFacing> list = new ArrayList<>(Arrays.asList(EnumFacing.VALUES));
list.remove(dir);
list.remove(dir.getOpposite());
if (renderState.pipeConnectionMatrix.isConnected(dir) && renderState.pipeConnectionMatrix.isConnected(dir.getOpposite())) {
boolean found = false;
for (EnumFacing dir2 : list) {
if (renderState.pipeConnectionMatrix.isConnected(dir2)) {
found = true;
break;
}
}
if (!found) {
switch(dir) {
case DOWN:
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.EAST_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.WEST_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.NORTH_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.SOUTH_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
break;
case NORTH:
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.EAST_UP), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.WEST_UP), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.UP_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.DOWN_SIDE), LogisticsNewRenderPipe.basicPipeTexture));
break;
case WEST:
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.UP_UP), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.DOWN_UP), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.NORTH_UP), LogisticsNewRenderPipe.basicPipeTexture));
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.supports.get(PipeSupport.SOUTH_UP), LogisticsNewRenderPipe.basicPipeTexture));
break;
default:
break;
}
}
}
}
boolean[] solidSides = new boolean[6];
if (pipeTile.getWorld() != null) {
// This can be null in some cases now !!!
for (EnumFacing dir : EnumFacing.VALUES) {
DoubleCoordinates pos = CoordinateUtils.add(new DoubleCoordinates((TileEntity) pipeTile), dir);
Block blockSide = pos.getBlock(pipeTile.getWorld());
if (blockSide == null || !blockSide.isSideSolid(pos.getBlockState(pipeTile.getWorld()), pipeTile.getWorld(), pos.getBlockPos(), dir.getOpposite()) || renderState.pipeConnectionMatrix.isConnected(dir)) {
mountCanidates.removeIf(mount -> mount.dir == dir);
} else {
solidSides[dir.ordinal()] = true;
}
}
mountCanidates.removeIf(mount -> SimpleServiceLocator.mcmpProxy.hasParts(pipeTile));
} else {
mountCanidates.clear();
}
if (!mountCanidates.isEmpty()) {
if (solidSides[EnumFacing.DOWN.ordinal()]) {
findOponentOnSameSide(mountCanidates, EnumFacing.DOWN);
} else if (solidSides[EnumFacing.UP.ordinal()]) {
findOponentOnSameSide(mountCanidates, EnumFacing.UP);
} else {
removeFromSide(mountCanidates, EnumFacing.DOWN);
removeFromSide(mountCanidates, EnumFacing.UP);
if (mountCanidates.size() > 2) {
removeIfHasOponentSide(mountCanidates);
}
if (mountCanidates.size() > 2) {
removeIfHasConnectedSide(mountCanidates);
}
if (mountCanidates.size() > 2) {
findOponentOnSameSide(mountCanidates, mountCanidates.get(0).dir);
}
}
if (LogisticsPipes.isDEBUG() && mountCanidates.size() > 2) {
new RuntimeException("Trying to render " + mountCanidates.size() + " Mounts").printStackTrace();
}
mountCanidates.stream().map(mount -> new RenderEntry(LogisticsNewRenderPipe.mounts.get(mount), LogisticsNewRenderPipe.basicPipeTexture)).forEach(objectsToRender::add);
}
for (EnumFacing dir : EnumFacing.VALUES) {
if (!renderState.pipeConnectionMatrix.isConnected(dir)) {
for (IModel3D model : LogisticsNewRenderPipe.texturePlate_Outer.get(dir)) {
TextureTransformation icon = Textures.LPnewPipeIconProvider.getIcon(renderState.textureMatrix.getTextureIndex());
if (icon != null) {
objectsToRender.add(new RenderEntry(model, new LPUVTransformationList(new LPUVScale(12f / 16, 12f / 16), icon)));
}
}
}
}
if (renderState.textureMatrix.isFluid()) {
for (EnumFacing dir : EnumFacing.VALUES) {
if (!renderState.pipeConnectionMatrix.isConnected(dir)) {
LogisticsNewRenderPipe.texturePlate_Inner.get(dir).stream().map(model -> new RenderEntry(model, new I3DOperation[] { LogisticsNewRenderPipe.glassCenterTexture })).forEach(objectsToRender::add);
} else {
if (!renderState.textureMatrix.isRoutedInDir(dir)) {
LogisticsNewRenderPipe.sideTexturePlate.get(dir).getValue1().stream().map(model -> new RenderEntry(model, new I3DOperation[] { LogisticsNewRenderPipe.basicPipeTexture })).forEach(objectsToRender::add);
}
}
}
}
SimpleServiceLocator.thermalDynamicsProxy.renderPipeConnections(pipeTile, objectsToRender);
}
use of logisticspipes.proxy.object3d.interfaces.TextureTransformation in project LogisticsPipes by RS485.
the class LogisticsNewRenderPipe method renderBoxWithDir.
public static void renderBoxWithDir(EnumFacing dir) {
List<RenderEntry> objectsToRender = new ArrayList<>();
List<Edge> edgesToRender = new ArrayList<>(Arrays.asList(Edge.values()));
Map<Corner, Integer> connectionAtCorner = new HashMap<>();
for (Edge edge : Edge.values()) {
if (edge.part1 == dir || edge.part2 == dir) {
edgesToRender.remove(edge);
}
}
for (Corner corner : Corner.values()) {
if (corner.ew.dir == dir || corner.ns.dir == dir || corner.ud.dir == dir) {
if (!connectionAtCorner.containsKey(corner)) {
connectionAtCorner.put(corner, 1);
} else {
connectionAtCorner.put(corner, connectionAtCorner.get(corner) + 1);
}
}
}
for (Corner corner : Corner.values()) {
TextureTransformation cornerTexture = LogisticsNewRenderPipe.basicPipeTexture;
int count = connectionAtCorner.getOrDefault(corner, 0);
if (count == 0) {
LogisticsNewRenderPipe.corners_M.get(corner).stream().map(model -> new RenderEntry(model, new I3DOperation[] { cornerTexture })).forEach(objectsToRender::add);
} else if (count == 1) {
for (PipeTurnCorner turn : PipeTurnCorner.values()) {
if (turn.corner != corner) {
continue;
}
if (turn.getPointer() == dir) {
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.spacers.get(turn), cornerTexture));
break;
}
}
} else if (count == 2) {
for (PipeTurnCorner turn : PipeTurnCorner.values()) {
if (turn.corner != corner) {
continue;
}
if (turn.getPointer() == dir) {
objectsToRender.add(new RenderEntry(LogisticsNewRenderPipe.corners_I.get(turn), cornerTexture));
break;
}
}
} else if (count == 3) {
LogisticsNewRenderPipe.corners_I3.get(corner).stream().map(model -> new RenderEntry(model, new I3DOperation[] { cornerTexture })).forEach(objectsToRender::add);
}
}
edgesToRender.stream().map(edge -> new RenderEntry(LogisticsNewRenderPipe.edges.get(edge), LogisticsNewRenderPipe.basicPipeTexture)).forEach(objectsToRender::add);
for (RenderEntry model : objectsToRender) {
model.getModel().render(model.getOperations());
}
}
use of logisticspipes.proxy.object3d.interfaces.TextureTransformation in project LogisticsPipes by RS485.
the class LogisticsBlockModel method generateBlockRenderList.
private List<RenderEntry> generateBlockRenderList(@Nullable IBlockState state, @Nonnull TextureAtlasSprite inactive, @Nonnull TextureAtlasSprite active) {
List<RenderEntry> objectsToRender = new ArrayList<>();
LogisticsNewSolidBlockWorldRenderer.BlockRotation rotation = LogisticsNewSolidBlockWorldRenderer.BlockRotation.ZERO;
TextureTransformation icon;
if (state != null) {
rotation = LogisticsNewSolidBlockWorldRenderer.BlockRotation.getRotation(state.getValue(LogisticsSolidBlock.rotationProperty));
icon = SimpleServiceLocator.cclProxy.createIconTransformer(state.getValue(LogisticsSolidBlock.active) ? active : inactive);
} else {
icon = SimpleServiceLocator.cclProxy.createIconTransformer(inactive);
}
// Draw
objectsToRender.add(new RenderEntry(LogisticsNewSolidBlockWorldRenderer.block.get(rotation), icon));
for (LogisticsNewSolidBlockWorldRenderer.CoverSides side : LogisticsNewSolidBlockWorldRenderer.CoverSides.values()) {
boolean render = true;
if (state != null) {
if (!state.getValue(LogisticsSolidBlock.connectionPropertys.get(side.getDir(rotation)))) {
render = false;
}
}
if (render) {
objectsToRender.add(new RenderEntry(LogisticsNewSolidBlockWorldRenderer.texturePlate_Outer.get(side).get(rotation), icon));
objectsToRender.add(new RenderEntry(LogisticsNewSolidBlockWorldRenderer.texturePlate_Inner.get(side).get(rotation), icon));
}
}
return objectsToRender;
}
Aggregations