the idea with chunking is more or less this :

by having a world with a lot of models/entities your
rendering time to render each separate model/entity
increases dramatically .

to try and reduce the rendering calls , you split your
world up in to volumes containing each a certain
amount of data , in this case that data would represent models/ entities , each volume can now
be referred to as a chunk ,if you ever looked at the gs
chunked terrain ,it works on the same principles those chunks store triangles of the large terrain
splitted up into separate pieces ,well its kind off the same concept. .

you need to create single meshes and entitys from a bunch of meshes and entitys , so that in total you reduce
the amount of entities while still having the required mesh geometry , your meshes could be procedural/ dynamic meshes wich you could remove /add faces to, based upon what faces is seen ..

These merged meshes /entities are then stored in chunks wich is a data array ,wich refers to these volumes of entities. .

then you can, based upon a view distance ,load and
unload these chunks of entities/models so that
enough is visible at a time to still keep your rendering time small enough while not looking to cheap .

basicly chunking reduces the amount of rendering calls by physically reducing the amount of entities and models ..

chunk sizes go a bit deeper because you cannot make your chunks to large or to small ..

you would have to research on it or you can take a look at the tust library for kubus wich is basically what I have described in bad english constructed sentences here..

chunking=joining splitting/slicing into chunks

edit: oh and by the way ,there is alot of memory management that goes into chunking a large area ,you need to unload data from memory you dont need
on screen and only load what you need ,usually you load a little a head of time so chunks dont just pop
up into view but seem to be there by the time you can view them , this loading is usually a backround threaded routine so you do not suddenly cause to much overhead on the main application thread .

jb