public bool isLoaded(Chunk chunk, BufferChunkFunc bufferFunc)
{
DrawChunk dc = findDrawChunk(chunk);
if (dc != null)
{
if (chunk.changeNumber == dc.changeNumber)
{
dc.lastFrameUsed = Renderer.frameNumber;
return(true);
}
//it's out of date, remove it to trigger a reload
updateChunk(chunk, bufferFunc);
return(true);
}
//it's been requested, we're working on it
if (myRequestedIds.Contains(chunk.key))
{
return(true);
}
return(false);
}
public void updateChunk(Chunk chunk, BufferChunkFunc bufferfunc)
{
removeChunk(chunk);
DrawChunk dc = bufferfunc(chunk);
lock (myLock)
{
myLoadedChunks[chunk.key] = dc;
}
}
public void removeChunk(Chunk chunk)
{
//actually free the area in memory
DrawChunk dc = findDrawChunk(chunk);
if (dc != null)
{
myMemory.dealloc(dc.mem);
}
lock (myLock)
{
myLoadedChunks.Remove(chunk.key);
}
}
public override DrawChunk bufferChunk(Chunk c)
{
c.updateVisisbility(); //this should be done offline
int bytesNeeded = c.visibleNodeCount * I1I1B12.stride;
BufferMemoryManager.Page mem = myRenderManager.memoryManager.alloc(bytesNeeded);
if (mem == null)
{
Warn.print("Not enough memory to buffer chunk-flushing video memory");
myRenderManager.removeStale();
mem = myRenderManager.memoryManager.alloc(bytesNeeded);
if (mem == null)
{
throw new Exception("Not enough memory in buffer. This is bad");
}
}
DrawChunk drawData = new DrawChunk();
drawData.changeNumber = c.changeNumber; //important for detecting changes
drawData.mem = mem;
drawData.firstOffset = (int)(mem.start.ToInt64() - myRenderManager.memoryManager.buffer.ptr.ToInt64()) / I1I1B12.stride;
int count = 0;
int offset = drawData.firstOffset;
IntPtr buffer = mem.start;
drawData.solidOffset = offset;
count = bufferNode(ref buffer, c.myRoot, Material.Property.SOLID);
drawData.solidCount = count;
offset += count;
drawData.transOffset = offset;
count = bufferNode(ref buffer, c.myRoot, Material.Property.TRANSPARENT);
drawData.transCount = count;
offset += count;
drawData.waterOffset = offset;
count = bufferNode(ref buffer, c.myRoot, Material.Property.WATER);
drawData.waterCount = count;
offset += count;
return(drawData);
}
public async void loadChunk(Chunk chunk, BufferChunkFunc bufferFunc)
{
if (myRequestedIds.Contains(chunk.key) == true) //already requested
{
return;
}
lock (myLock)
{
myRequestedIds.Add(chunk.key);
}
DrawChunk dc = await bufferChunkAsync(chunk, bufferFunc);
//DrawChunk dc = bufferFunc(chunk);
//finished the async call
lock (myLock)
{
myLoadedChunks[chunk.key] = dc;
myRequestedIds.Remove(chunk.key);
}
}
//public override void preparePerFrame(Renderable r) { }
//public override void preparePerViewBegin(View v) { }
//public override void preparePerView(Renderable r, View v) { }
//public override void preparePerViewFinalize(View v) { }
//public override void preparePerPassBegin(Pass p) { }
public override void preparePerPass(Renderable r, Pass p)
{
TerrainRenderable tr = r as TerrainRenderable;
Chunk c = tr.myChunk;
if (myRenderManager.isLoaded(c, bufferChunk) == false)
{
myRenderManager.loadChunk(c, bufferChunk);
return;
}
//DebugRenderer.addOffsetCube(c.myLocation, c.mySize, Color4.Blue, Fill.WIREFRAME, false, 0.0f);
DrawChunk dc = myRenderManager.findDrawChunk(c);
if (dc != null)
{
Matrix4 m = Matrix4.CreateTranslation(c.myLocation);
//add solid render info
if (dc.solidCount > 0)
{
MaterialEffect effect = getEffect(p.technique, 1);
PipelineState pipeline = effect.createPipeline(MaterialManager.visualMaterial);
RenderQueue <TerrainRenderInfo> rq = p.findRenderQueue(pipeline.id) as RenderQueue <TerrainRenderInfo>;
if (rq == null)
{
rq = Renderer.device.createRenderQueue <TerrainRenderInfo>(effect.createPipeline(MaterialManager.visualMaterial));
rq.name = rq.myPipeline.shaderState.shaderProgram.name + "-" + "opaque";
rq.visualizer = this;
p.registerQueue(rq);
}
TerrainRenderInfo info = rq.nextInfo();
info.distToCamera = (p.view.camera.position - c.myLocation).Length;
info.model = m;
info.myType = TerrainRenderInfo.Type.SOLID;
info.count = dc.solidCount;
info.offset = dc.solidOffset;
info.sortId = getSortId(info);
effect.updateRenderState(MaterialManager.visualMaterial, info.renderState);
addDraw(info.offset, info.count, info.model);
}
//add transparent render info
if (dc.transCount > 0)
{
MaterialEffect effect = getEffect(p.technique, 2);
PipelineState pipeline = effect.createPipeline(MaterialManager.visualMaterial);
RenderQueue <TerrainRenderInfo> rq = p.findRenderQueue(pipeline.id) as RenderQueue <TerrainRenderInfo>;
if (rq == null)
{
rq = Renderer.device.createRenderQueue <TerrainRenderInfo>(effect.createPipeline(MaterialManager.visualMaterial));
rq.name = rq.myPipeline.shaderState.shaderProgram.name + "-" + "transparent";
rq.visualizer = this;
p.registerQueue(rq);
}
TerrainRenderInfo info = rq.nextInfo();
info.distToCamera = (p.view.camera.position - c.myLocation).Length;
info.model = m;
info.myType = TerrainRenderInfo.Type.TRANS;
info.count = dc.transCount;
info.offset = dc.transOffset;
info.sortId = getSortId(info);
effect.updateRenderState(MaterialManager.visualMaterial, info.renderState);
addDraw(info.offset, info.count, info.model);
}
//add water renderinfo
if (dc.waterCount > 0)
{
MaterialEffect effect = getEffect(p.technique, 3);
PipelineState pipeline = effect.createPipeline(MaterialManager.visualMaterial);
RenderQueue <TerrainRenderInfo> rq = p.findRenderQueue(pipeline.id) as RenderQueue <TerrainRenderInfo>;
if (rq == null)
{
rq = Renderer.device.createRenderQueue <TerrainRenderInfo>(effect.createPipeline(MaterialManager.visualMaterial));
rq.name = rq.myPipeline.shaderState.shaderProgram.name + "-" + "water";
rq.visualizer = this;
p.registerQueue(rq);
}
TerrainRenderInfo info = rq.nextInfo();
info.distToCamera = (p.view.camera.position - c.myLocation).Length;
info.model = m;
info.myType = TerrainRenderInfo.Type.WATER;
info.count = dc.waterCount;
info.offset = dc.waterOffset;
info.sortId = getSortId(info);
effect.updateRenderState(MaterialManager.visualMaterial, info.renderState);
addDraw(info.offset, info.count, info.model);
}
}
}
