# mcedit2.rendering package — mceditlib 0.1 documentation

### Navigation

- index
- modules |
- next |
- previous |
- mceditlib 0.1 documentation »
- mcedit2 package »

# mcedit2.rendering package

## Subpackages

- mcedit2.rendering.chunkmeshes package
  - Submodules
  - mcedit2.rendering.chunkmeshes.entitymesh module
  - mcedit2.rendering.chunkmeshes.lowdetail module
  - mcedit2.rendering.chunkmeshes.terrainpop module
  - mcedit2.rendering.chunkmeshes.tileticks module
  - Module contents

## Submodules

## mcedit2.rendering.blockmeshes module

`mcedit2.rendering.blockmeshes.``makeVertexTemplates`(xmin=0, ymin=0, zmin=0, xmax=1, ymax=1, zmax=1)

class `mcedit2.rendering.blockmeshes.``MeshBase`

  Bases: `object`

  `detailLevels` = (0,)
  `detailLevel` = 0
  `layer` = u'Blocks'
  `renderType` = NotImplemented
  `extraTextures` = ()
  `renderstate`

    alias of `RenderstateAlphaTestNode`

  `vertexArrays` = ()
  `bufferSize`()

class `mcedit2.rendering.blockmeshes.``ChunkMeshBase`(chunkUpdate)

  Bases: `mcedit2.rendering.blockmeshes.MeshBase`

## mcedit2.rendering.blockmodels module

blockmodels

class `mcedit2.rendering.blockmodels.``BlockModels`

  Bases: `object`

  `cookFluidQuads`()
  `cookQuads`()
  `firstTextures`
  `getTextureNames`()

class `mcedit2.rendering.blockmodels.``FaceInfo`

  Bases: `object`

`mcedit2.rendering.blockmodels.``npRotate`(*args, **kwds)

## mcedit2.rendering.chunkloader module

${NAME}

class `mcedit2.rendering.chunkloader.``ChunkLoaderInfo`

  Bases: `mcedit2.widgets.infopanel.InfoPanel`

  `client`
  `staticMetaObject` = <PySide.QtCore.QMetaObject object at 0x00000000056B9CC8>

class `mcedit2.rendering.chunkloader.``IChunkLoaderClient`

  Bases: `object`

  `requestChunk`()

    Return the coordinates of the chunk requested by the client. Each call may return a different set of coordinates. Return None to request no chunks. :rtype: (cx, cz) :return: Chunk coordinates

  `wantsChunk`((cx, cz))

    Optional.

    Return False to skip loading the chunk at the given position. If all clients return False, the chunk is not loaded.

    Return type: | boolean

  `recieveChunk`(chunk)

    Process the chunk. May be implemented as a generator function or a function that returns an iterable - if `recieve chunk` returns an iterable, it will be exhausted

    Parameters: | chunk – returned by level.getChunk()
    Returns: | See description
    Return type: | None or iterator

  `chunkNotLoaded`((cx, cz), exc)

    Notifies the client that a chunk failed to load with an exception. :param (cx, cz): chunk position

class `mcedit2.rendering.chunkloader.``ChunkLoader`(dimension, *args, **kwargs)

  Bases: `PySide.QtCore.QObject`

  `chunkCompleted` = <PySide.QtCore.Signal object at 0x00000000045B7D50>
  `allChunksDone` = <PySide.QtCore.Signal object at 0x00000000045B7D88>
  `cps`
  `addClient`(client, index=-1)

  `removeClient`(client)

  `removeAllClients`()
  `next`()
  `discardChunks`(chunks)
  `discardChunk`(cx, cz)
  `staticMetaObject` = <PySide.QtCore.QMetaObject object at 0x00000000045B10C8>

## mcedit2.rendering.chunknode module

${NAME}

class `mcedit2.rendering.chunknode.``ChunkRenderInfo`(worldScene, chunkPosition)

  Bases: `object`

  `maxlod` = 2
  `minlod` = 0
  `getChunkVertexNodes`()
  `visibleLayers`
  `done`

class `mcedit2.rendering.chunknode.``ChunkNode`(chunkPosition)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `TranslateRenderNode`

class `mcedit2.rendering.chunknode.``ChunkGroupNode`

  Bases: `mcedit2.rendering.scenegraph.NamedChildrenNode`

  Stores chunks in a group of subnodes, each storing 4x4 chunks. Reduces the number of chunk nodes whose parent
    node must be redrawn when a chunk is added or removed.
  `getChunkArea`(cx, cz, create=True)
  `dropChunkArea`(cx, cz)
  `containsChunkNode`((cx, cz))
  `getChunkNode`((cx, cz))
  `addChunkNode`(chunkNode)
  `discardChunkNode`(cx, cz)
  `chunkPositions`()
  `clear`()

## mcedit2.rendering.chunkupdate module

${NAME}

class `mcedit2.rendering.chunkupdate.``ChunkUpdate`(updateTask, chunkInfo, chunk)

  Bases: `object`

  `neighboringChunks`
  `textureAtlas`
  `fastLeaves`
  `roughGraphics`
  `wholeChunkMeshClasses` = [<class 'mcedit2.rendering.chunkmeshes.entitymesh.TileEntityMesh'>, <class 'mcedit2.rendering.chunkmeshes.entitymesh.MonsterRenderer'>, <class 'mcedit2.rendering.chunkmeshes.entitymesh.ItemRenderer'>, <class 'mcedit2.rendering.chunkmeshes.tileticks.TileTicksRenderer'>, <class 'mcedit2.rendering.chunkmeshes.terrainpop.TerrainPopulatedRenderer'>, <class 'mcedit2.rendering.chunkmeshes.lowdetail.LowDetailBlockMesh'>, <class 'mcedit2.rendering.chunkmeshes.lowdetail.OverheadBlockMesh'>]
  `buildChunkMeshes`(*a, **kw)

    Rebuild the meshes which render the entire chunk from top to bottom :return: :rtype:

  `buildSectionMeshes`(*a, **kw)

    Rebuild the section meshes.

    Creates a SectionUpdate instance for each section found in this ChunkUpdate’s chunk and iterates it. Returns an iterator.

class `mcedit2.rendering.chunkupdate.``SectionUpdate`(chunkUpdate, chunkSection, blockMeshes)

  Bases: `object`

  `fastLeaves`
  `roughGraphics`
  `areaBlocks`
  `areaData`
  `areaBlocksOrData`(arrayName)

    Return the blocks in an 18-wide cube centered on this section. Only retrieves blocks from the 6 sections neighboring this one along a major axis, so the corners are empty. That’s fine since they aren’t needed for any calculation we do.

    Returns: | Array of blocks in this chunk and six of its neighbors.
    Return type: | numpy.ndarray(shape=(18, 18, 18), dtype=’uint16’)

  `blocktypes`
  `renderType`
  `exposedBlockMasks`
  `areaLights`(lightName)
  `areaBlockLights`
  `areaSkyLights`
  `Blocks`
  `Data`

## mcedit2.rendering.compass module

compass

`mcedit2.rendering.compass.``makeQuad`(minx, miny, width, height)

class `mcedit2.rendering.compass.``CompassRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `compile`()
  `drawSelf`()

class `mcedit2.rendering.compass.``CompassNode`(small=False)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `CompassRenderNode`

  `yawPitch`

## mcedit2.rendering.cubes module

${NAME}

`mcedit2.rendering.cubes.``drawBox`(box, cubeType=GL_QUADS, texture=None, textureVertices=None, selectionBox=False)

  pass a different cubeType e.g. GL_LINE_STRIP for wireframes

`mcedit2.rendering.cubes.``drawFace`(box, face, elementType=GL_QUADS)

`mcedit2.rendering.cubes.``drawConstructionCube`(box, color, texture=None)

`mcedit2.rendering.cubes.``drawTerrainCuttingWire`(box, c0=(0.75, 0.75, 0.75, 0.4), c1=(1.0, 1.0, 1.0, 1.0))

## mcedit2.rendering.depths module

Copyright (c) 2010-2012 David Rio Vierra

Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.

THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

class `mcedit2.rendering.depths.``DepthOffset`

  Bases: `object`

  `ChunkMarkers` = 2
  `Renderer` = 1
  `PreviewRenderer` = 0
  `TerrainWire` = -1
  `Selection` = -1
  `ClonePreview` = -2
  `SelectionCorners` = -2
  `PotentialSelection` = -3
  `FillMarkers` = -3
  `CloneMarkers` = -3
  `CloneCursor` = -3
  `SelectionCursor` = -4

## mcedit2.rendering.frustum module

View frustum modeling as series of clipping planes

Based on code from:
  http://www.markmorley.com/opengl/frustumculling.html

`mcedit2.rendering.frustum.``viewingMatrix`(projection=None, model=None)

  Calculate the total viewing matrix from given data

  projection – the projection matrix, if not provided
    than the result of glGetDoublev( GL_PROJECTION_MATRIX) will be used.
  model – the model-view matrix, if not provided
    than the result of glGetDoublev( GL_MODELVIEW_MATRIX ) will be used.
  Note:
    Unless there is a valid projection and model-view matrix, the function will raise a RuntimeError

class `mcedit2.rendering.frustum.``Frustum`

  Bases: `object`

  Holder for frustum specification for intersection tests

  Note:
    the Frustum can include an arbitrary number of clipping planes, though the most common usage is to define 6 clipping planes from the OpenGL model-view matrices.
  `visible`(points, radius)

    Determine whether this sphere is visible in frustum

    frustum – Frustum object holding the clipping planes
      for the view
    matrix – a matrix which transforms the local
      coordinates to the (world-space) coordinate system in which the frustum is defined.

    This version of the method uses a pure-python loop to do the actual culling once the points are multiplied by the matrix. (i.e. it does not use the frustcullaccel C extension module)

  `visible1`(point, radius)
  classmethod `fromViewingMatrix`(matrix=None, normalize=1)

    Extract and calculate frustum clipping planes from OpenGL

    The default initializer allows you to create Frustum objects with arbitrary clipping planes, while this alternate initializer provides automatic clipping-plane extraction from the model-view matrix.

    matrix – the combined model-view matrix normalize – whether to normalize the plane equations

    > to allow for sphere bounding-volumes and use of distance equations for LOD-style operations.

  classmethod `normalize`(frustum)

    Normalize clipping plane equations

## mcedit2.rendering.geometrycache module

geometrycache

class `mcedit2.rendering.geometrycache.``GeometryCache`(*a, **kwargs)

  Bases: `dict`

`mcedit2.rendering.geometrycache.``cache_stats`()

## mcedit2.rendering.layers module

${NAME}

class `mcedit2.rendering.layers.``Layer`
  `Blocks` = u'Blocks'
  `Entities` = u'Entities'
  `Monsters` = u'Monsters'
  `Items` = u'Items'
  `TileEntities` = u'TileEntities'
  `TileTicks` = u'TileTicks'
  `TerrainPopulated` = u'TerrainPopulated'
  `AllLayers` = (u'Blocks', u'Entities', u'Monsters', u'Items', u'TileEntities', u'TileTicks')

## mcedit2.rendering.lightmap module

lightmap

`mcedit2.rendering.lightmap.``generateLightBrightnessTable`(minLight=0.0)

`mcedit2.rendering.lightmap.``generateLightmap`(darkness, theEnd=False, gamma=0.5)

`mcedit2.rendering.lightmap.``main`()

## mcedit2.rendering.loadablechunks module

${NAME}

class `mcedit2.rendering.loadablechunks.``LoadableChunksRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()
  `floorTexture`

class `mcedit2.rendering.loadablechunks.``LoadableChunksNode`(dimension)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `skipLargeLevels` = False
  `RenderNodeClass`

    alias of `LoadableChunksRenderNode`

  `createVertexArrays`()

`mcedit2.rendering.loadablechunks.``makeFloorTex`()

`mcedit2.rendering.loadablechunks.``chunkMarkers`(chunkSet)

  Returns a mapping { size: [position, ...] } for different powers of 2 as size.

## mcedit2.rendering.modelmesh module

${NAME}

class `mcedit2.rendering.modelmesh.``BlockModelMesh`

  Bases: `object`

  `createVertexArrays`()
  `renderstate`

    alias of `RenderstateAlphaTestNode`

## mcedit2.rendering.rendergraph module

${NAME}

class `mcedit2.rendering.rendergraph.``RenderNode`(sceneNode)

  Bases: `object`

  `parent`
  `addChild`(node)
  `insertNode`(index, node)
  `removeChild`(node)
  `invalidate`()
  `touch`()
  `getList`()
  `callList`()
  `compile`()
  `draw`()
  `drawChildren`()
  `drawSelf`()
  `destroyLists`()

class `mcedit2.rendering.rendergraph.``RenderstateRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `draw`()
  `enter`()
  `exit`()

class `mcedit2.rendering.rendergraph.``TextureAtlasRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `compile`()
  `enter`()
  `exit`()

class `mcedit2.rendering.rendergraph.``TranslateRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.rendergraph.``VertexRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `invalidate`()
  `drawSelf`()
  `drawArrays`(vertexArrays, textures, lights)

class `mcedit2.rendering.rendergraph.``OrthoRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.rendergraph.``ClearRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()

class `mcedit2.rendering.rendergraph.``DepthMaskRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.rendergraph.``BoxRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()

class `mcedit2.rendering.rendergraph.``BoxFaceRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawBoxFace`(box, face, color=(0.9, 0.6, 0.2, 0.5))

class `mcedit2.rendering.rendergraph.``DepthOffsetRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

`mcedit2.rendering.rendergraph.``updateRenderNode`(renderNode)

`mcedit2.rendering.rendergraph.``createRenderNode`(sceneNode)

  Return type: | mcedit2.rendering.rendergraph.RenderNode

`mcedit2.rendering.rendergraph.``updateChildren`(renderNode)

  Returns: |
  Return type: |

`mcedit2.rendering.rendergraph.``renderScene`(renderNode)

## mcedit2.rendering.renderstates module

renderstates

class `mcedit2.rendering.renderstates.``RenderstatePlainNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.renderstates.``RenderstateVinesNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.renderstates.``RenderstateLowDetailNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.renderstates.``RenderstateAlphaTestNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.renderstates.``RenderstateWaterNode`(sceneNode)

  Bases: `mcedit2.rendering.renderstates._RenderstateAlphaBlendNode`

class `mcedit2.rendering.renderstates.``RenderstateIceNode`(sceneNode)

  Bases: `mcedit2.rendering.renderstates._RenderstateAlphaBlendNode`

class `mcedit2.rendering.renderstates.``RenderstateEntityNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

## mcedit2.rendering.scenegraph module

scenegraph

class `mcedit2.rendering.scenegraph.``Node`

  Bases: `object`

  `RenderNodeClass`

    alias of `RenderNode`

  `parent`
  `touchChildren`()
  `addChild`(node)
  `insertChild`(index, node)
  `removeChild`(node)
  `clear`()
  `children`
  `dirty`
  `visible`

class `mcedit2.rendering.scenegraph.``NamedChildrenNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `RenderNode`

  `addChild`(name, node)
  `insertChild` = NotImplemented
  `removeChild`(name)
  `getChild`(name)
  `clear`()
  `children`

class `mcedit2.rendering.scenegraph.``RenderstateNode`(nodeClass)

  Bases: `mcedit2.rendering.scenegraph.Node`

class `mcedit2.rendering.scenegraph.``TextureAtlasNode`(textureAtlas)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `TextureAtlasRenderNode`

class `mcedit2.rendering.scenegraph.``TranslateNode`(translateOffset=(0.0, 0.0, 0.0))

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `TranslateRenderNode`

  `translateOffset`

class `mcedit2.rendering.scenegraph.``DepthMaskNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `DepthMaskRenderNode`

  `mask` = False

class `mcedit2.rendering.scenegraph.``ClearNode`(clearColor=(0, 0, 0, 1))

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `ClearRenderNode`

class `mcedit2.rendering.scenegraph.``OrthoNode`(size=(1, 1))

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `OrthoRenderNode`

  `size`

class `mcedit2.rendering.scenegraph.``VertexNode`(vertexArrays)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `VertexRenderNode`

class `mcedit2.rendering.scenegraph.``MatrixRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.scenegraph.``MatrixNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `MatrixRenderNode`

  `projection`

    Returns: |
    Return type: | QMatrix4x4

  `modelview`

    Returns: |
    Return type: | QMatrix4x4

class `mcedit2.rendering.scenegraph.``DepthOffsetNode`(depthOffset)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `DepthOffsetRenderNode`

## mcedit2.rendering.selection module

selection

class `mcedit2.rendering.selection.``CullFaceRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderstateRenderNode`

  `enter`()
  `exit`()

class `mcedit2.rendering.selection.``NonAirMaskSelection`(dimension, box)

  Bases: `mceditlib.selection.SelectionBox`

  `box_mask`(box)

    Parameters: | box (BoundingBox) –
    Returns: |
    Return type: |

class `mcedit2.rendering.selection.``SelectionScene`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `selection`
  `dimension`
  `filled`
  `updateSelection`()
  `loadMore`()
  `loadSections`(*a, **kw)
  `exposedBlockMasks`(mask)

    Compare adjacent cells in the 3d mask along all three axes and return one mask for each cardinal direction. The returned masks contain the faces of each cell which are exposed in that direction and should be rendered.

    Parameters: | mask (ndarray) –
    Returns: |
    Return type: | list[ndarray]

  `buildSection`(sectionMask, cy)

class `mcedit2.rendering.selection.``SelectionBoxRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()

class `mcedit2.rendering.selection.``SelectionBoxNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `SelectionBoxRenderNode`

  `depth` = -1
  `wire` = True
  `filled`
  `selectionBox`
  `color`
  `wireColor`

class `mcedit2.rendering.selection.``SelectionFaceRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()

class `mcedit2.rendering.selection.``SelectionFaceNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `SelectionFaceRenderNode`

  `depth` = -1
  `selectionBox`
  `face`
  `color`

`mcedit2.rendering.selection.``boxFaceUnderCursor`(box, mouseRay)

  Find the nearest face of the given bounding box that intersects with the given mouse ray and return (point, face)

## mcedit2.rendering.sky module

sky

class `mcedit2.rendering.sky.``SkyRenderNode`(sceneNode)

  Bases: `mcedit2.rendering.rendergraph.RenderNode`

  `drawSelf`()

class `mcedit2.rendering.sky.``SkyNode`

  Bases: `mcedit2.rendering.scenegraph.Node`

  `RenderNodeClass`

    alias of `SkyRenderNode`

## mcedit2.rendering.slices module

slices

## mcedit2.rendering.textureatlas module

textureatlas

class `mcedit2.rendering.textureatlas.``TextureSlot`(left, top, right, bottom)

  Bases: `object`

  `width`
  `height`
  `addTexture`(name, w, h, d)

`mcedit2.rendering.textureatlas.``allTextureNames`(blocktypes)

class `mcedit2.rendering.textureatlas.``TextureAtlas`(world, resourceLoader, blockModels, maxLOD=0, overrideMaxSize=None)

  Bases: `object`

  `load`()
  `bindTerrain`()
  `dayTime`
  `minBrightness`
  `bindLight`()
  `dispose`()

`mcedit2.rendering.textureatlas.``getGLMaximumTextureSize`()

`mcedit2.rendering.textureatlas.``test_TextureAtlas`()

## mcedit2.rendering.vertexarraybuffer module

${NAME}

class `mcedit2.rendering.vertexarraybuffer.``VertexArrayBuffer`(count, textures=True, lights=True)

  Bases: `object`

  `texOffset` = None
  `lightOffset` = None
  classmethod `fromIndices`(face, blockIndices, textures=True, lights=True)

    Parameters:

    - face –
    - blockIndices –
    - textures –
    - lights –

    Returns: |
    Return type: | VertexArrayBuffer

  `copy`()
  `setLights`(skyLight, blockLight)
  `applyTexMap`(ltwh)
  `vertex`
  `texcoord`
  `lightcoord`
  `rgba`
  `rgb`
  `alpha`

## mcedit2.rendering.worldscene module

${NAME}

`mcedit2.rendering.worldscene.``layerProperty`(layer, default=True)

class `mcedit2.rendering.worldscene.``SceneUpdateTask`(worldScene, textureAtlas, bounds=None)

  Bases: `object`

  `showRedraw` = True
  `showHiddenOres` = False
  `showChunkRedraw` = True
  `spaceHeight` = 64
  `targetFPS` = 30
  `overheadMode` = False
  `maxWorkFactor` = 64
  `minWorkFactor` = 1
  `workFactor` = 2
  `wantsChunk`(cPos)
  `workOnChunk`(chunk, visibleSections=None)

class `mcedit2.rendering.worldscene.``WorldScene`(dimension, textureAtlas, geometryCache=None, bounds=None)

  Bases: `mcedit2.rendering.scenegraph.Node`

  `chunkPositions`()
  `getRenderstateGroup`(rsClass)
  `discardChunk`(cx, cz)

    Discard the chunk at the given position from the scene

  `discardChunks`(chunks)
  `discardAllChunks`()
  `invalidateChunk`(cx, cz, invalidLayers=None)

    Mark the chunk for regenerating vertex data

  `fastLeaves`
  `roughGraphics`
  `showHiddenOres`
  `wantsChunk`(cPos)
  `workOnChunk`(chunk, visibleSections=None)
  `getChunkRenderInfo`(cPos)

## Module contents

### Navigation

- index
- modules |
- next |
- previous |
- mceditlib 0.1 documentation »
- mcedit2 package »