public void Render3D(GCodeRenderInfo renderInfo)
{
if (layerVertexBuffer == null)
{
layerVertexBuffer = new List <GCodeVertexBuffer>();
layerVertexBuffer.Capacity = gCodeFileToDraw.NumChangesInZ;
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
layerVertexBuffer.Add(null);
featureStartIndex.Add(new List <int>());
featureEndIndex.Add(new List <int>());
}
}
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
CreateFeaturesForLayerIfRequired(layerIndex);
}
if (lastRenderType != renderInfo.CurrentRenderType)
{
Clear3DGCode();
lastRenderType = renderInfo.CurrentRenderType;
}
if (renderFeatures.Count > 0)
{
for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--)
{
// If its the first render or we change what we are trying to render then create vertex data.
if (layerVertexBuffer[i] == null)
{
VectorPOD <ColorVertexData> colorVertexData = new VectorPOD <ColorVertexData>();
VectorPOD <int> vertexIndexArray = new VectorPOD <int>();
Create3DDataForLayer(i, colorVertexData, vertexIndexArray, renderInfo);
layerVertexBuffer[i] = new GCodeVertexBuffer();
layerVertexBuffer[i].SetVertexData(colorVertexData.Array);
layerVertexBuffer[i].SetIndexData(vertexIndexArray.Array);
}
}
GL.Disable(EnableCap.Texture2D);
GL.PushAttrib(AttribMask.EnableBit);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.Enable(EnableCap.PolygonSmooth);
if (renderInfo.EndLayerIndex - 1 > renderInfo.StartLayerIndex)
{
for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex - 1; i++)
{
int featuresOnLayer = renderFeatures[i].Count;
if (featuresOnLayer > 1)
{
layerVertexBuffer[i].renderRange(0, featureEndIndex[i][featuresOnLayer - 1]);
}
}
}
// draw the partial layer of end-1 from startRatio to endRatio
{
int layerIndex = renderInfo.EndLayerIndex - 1;
int featuresOnLayer = renderFeatures[layerIndex].Count;
int startFeature = (int)(featuresOnLayer * renderInfo.FeatureToStartOnRatio0To1 + .5);
startFeature = Math.Max(0, Math.Min(startFeature, featuresOnLayer));
int endFeature = (int)(featuresOnLayer * renderInfo.FeatureToEndOnRatio0To1 + .5);
endFeature = Math.Max(0, Math.Min(endFeature, featuresOnLayer));
// try to make sure we always draw at least one feature
if (endFeature <= startFeature)
{
endFeature = Math.Min(startFeature + 1, featuresOnLayer);
}
if (startFeature >= endFeature)
{
// This can only happen if the start and end are set to the last feature
// Try to set the start feature to one from the end
startFeature = Math.Max(endFeature - 1, 0);
}
if (endFeature > startFeature)
{
int ellementCount = featureEndIndex[layerIndex][endFeature - 1] - featureStartIndex[layerIndex][startFeature];
layerVertexBuffer[layerIndex].renderRange(featureStartIndex[layerIndex][startFeature], ellementCount);
}
}
GL.PopAttrib();
}
}
public void Render3D(GCodeRenderInfo renderInfo)
{
if (layerVertexBuffer == null)
{
layerVertexBuffer = new List<GCodeVertexBuffer>();
layerVertexBuffer.Capacity = gCodeFileToDraw.NumChangesInZ;
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
layerVertexBuffer.Add(null);
featureStartIndex.Add(new List<int>());
featureEndIndex.Add(new List<int>());
}
}
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
CreateFeaturesForLayerIfRequired(layerIndex);
}
if (lastRenderType != renderInfo.CurrentRenderType)
{
Clear3DGCode();
lastRenderType = renderInfo.CurrentRenderType;
}
if (renderFeatures.Count > 0)
{
for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex; i++)
{
// If its the first render or we change what we are trying to render then create vertex data.
if (layerVertexBuffer[i] == null)
{
VectorPOD<ColorVertexData> colorVertexData = new VectorPOD<ColorVertexData>();
VectorPOD<int> vertexIndexArray = new VectorPOD<int>();
Create3DDataForLayer(i, colorVertexData, vertexIndexArray, renderInfo);
layerVertexBuffer[i] = new GCodeVertexBuffer();
layerVertexBuffer[i].SetVertexData(colorVertexData.Array);
layerVertexBuffer[i].SetIndexData(vertexIndexArray.Array);
}
}
GL.Disable(EnableCap.Texture2D);
GL.PushAttrib(AttribMask.EnableBit);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.Enable(EnableCap.PolygonSmooth);
if (renderInfo.EndLayerIndex - 1 > renderInfo.StartLayerIndex)
{
for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex - 1; i++)
{
int featuresOnLayer = renderFeatures[i].Count;
if (featuresOnLayer > 1)
{
layerVertexBuffer[i].renderRange(0, featureEndIndex[i][featuresOnLayer - 1]);
}
}
}
// draw the partial layer of end-1 from startRatio to endRatio
{
int layerIndex = renderInfo.EndLayerIndex - 1;
int featuresOnLayer = renderFeatures[layerIndex].Count;
int startFeature = (int)(featuresOnLayer * renderInfo.FeatureToStartOnRatio0To1 + .5);
startFeature = Math.Max(0, Math.Min(startFeature, featuresOnLayer));
int endFeature = (int)(featuresOnLayer * renderInfo.FeatureToEndOnRatio0To1 + .5);
endFeature = Math.Max(0, Math.Min(endFeature, featuresOnLayer));
// try to make sure we always draw at least one feature
if (endFeature <= startFeature)
{
endFeature = Math.Min(startFeature + 1, featuresOnLayer);
}
if (startFeature >= endFeature)
{
// This can only happen if the sart and end are set to the last feature
// Try to set the start feture to one from the end
startFeature = Math.Max(endFeature - 1, 0);
}
if (endFeature > startFeature)
{
int ellementCount = featureEndIndex[layerIndex][endFeature - 1] - featureStartIndex[layerIndex][startFeature];
layerVertexBuffer[layerIndex].renderRange(featureStartIndex[layerIndex][startFeature], ellementCount);
}
}
GL.PopAttrib();
}
}
public void Render3D(GCodeRenderInfo renderInfo)
{
if (layerVertexBuffer == null)
{
layerVertexBuffer = new List<GCodeVertexBuffer>();
layerVertexBuffer.Capacity = gCodeFileToDraw.NumChangesInZ;
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
layerVertexBuffer.Add(null);
featureStartIndex.Add(new List<int>());
featureEndIndex.Add(new List<int>());
}
}
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
CreateFeaturesForLayerIfRequired(layerIndex);
}
if (lastRenderType != renderInfo.CurrentRenderType)
{
Clear3DGCode();
lastRenderType = renderInfo.CurrentRenderType;
}
if (renderFeatures.Count > 0)
{
if (Is32Bit() && !GL.GlHasBufferObjects)
{
int maxFeaturesForThisSystem = 125000;
int totalFeaturesToRunder = 0;
bool cleanUnusedLayers = false;
// if on 32 bit system make sure we don't run out of memory rendering too many features
for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--)
{
if (totalFeaturesToRunder + renderFeatures[i].Count < maxFeaturesForThisSystem)
{
totalFeaturesToRunder += renderFeatures[i].Count;
}
else // don't render any of the layers below this and in fact remove them from memory if possible
{
renderInfo.startLayerIndex = i + 1;
cleanUnusedLayers = true;
break;
}
}
if (cleanUnusedLayers)
{
// no remove any layers that are set that we are not going to render
for (int removeIndex = 0; removeIndex < layerVertexBuffer.Count; removeIndex++)
{
if (removeIndex < renderInfo.StartLayerIndex || removeIndex >= renderInfo.EndLayerIndex)
{
if (layerVertexBuffer[removeIndex] != null)
{
layerVertexBuffer[removeIndex].Dispose();
layerVertexBuffer[removeIndex] = null;
}
}
}
}
}
for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--)
{
// If its the first render or we change what we are trying to render then create vertex data.
if (layerVertexBuffer[i] == null)
{
VectorPOD<ColorVertexData> colorVertexData = new VectorPOD<ColorVertexData>();
VectorPOD<int> vertexIndexArray = new VectorPOD<int>();
Create3DDataForLayer(i, colorVertexData, vertexIndexArray, renderInfo);
layerVertexBuffer[i] = new GCodeVertexBuffer();
layerVertexBuffer[i].SetVertexData(colorVertexData.Array);
layerVertexBuffer[i].SetIndexData(vertexIndexArray.Array);
}
}
GL.Disable(EnableCap.Texture2D);
GL.PushAttrib(AttribMask.EnableBit);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.Enable(EnableCap.PolygonSmooth);
if (renderInfo.EndLayerIndex - 1 > renderInfo.StartLayerIndex)
{
for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex - 1; i++)
{
int featuresOnLayer = renderFeatures[i].Count;
if (featuresOnLayer > 1)
{
layerVertexBuffer[i].renderRange(0, featureEndIndex[i][featuresOnLayer - 1]);
}
}
}
// draw the partial layer of end-1 from startRatio to endRatio
{
int layerIndex = renderInfo.EndLayerIndex - 1;
int featuresOnLayer = renderFeatures[layerIndex].Count;
int startFeature = (int)(featuresOnLayer * renderInfo.FeatureToStartOnRatio0To1 + .5);
startFeature = Math.Max(0, Math.Min(startFeature, featuresOnLayer));
int endFeature = (int)(featuresOnLayer * renderInfo.FeatureToEndOnRatio0To1 + .5);
endFeature = Math.Max(0, Math.Min(endFeature, featuresOnLayer));
// try to make sure we always draw at least one feature
if (endFeature <= startFeature)
{
endFeature = Math.Min(startFeature + 1, featuresOnLayer);
}
if (startFeature >= endFeature)
{
// This can only happen if the sart and end are set to the last feature
// Try to set the start feture to one from the end
startFeature = Math.Max(endFeature - 1, 0);
}
if (endFeature > startFeature)
{
int ellementCount = featureEndIndex[layerIndex][endFeature - 1] - featureStartIndex[layerIndex][startFeature];
layerVertexBuffer[layerIndex].renderRange(featureStartIndex[layerIndex][startFeature], ellementCount);
}
}
GL.PopAttrib();
}
}
public void Render3D(GCodeRenderInfo renderInfo)
{
if (layerVertexBuffer == null)
{
layerVertexBuffer = new List <GCodeVertexBuffer>();
layerVertexBuffer.Capacity = gCodeFileToDraw.NumChangesInZ;
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
layerVertexBuffer.Add(null);
featureStartIndex.Add(new List <int>());
featureEndIndex.Add(new List <int>());
}
}
for (int layerIndex = 0; layerIndex < gCodeFileToDraw.NumChangesInZ; layerIndex++)
{
CreateFeaturesForLayerIfRequired(layerIndex);
}
if (lastRenderType != renderInfo.CurrentRenderType)
{
Clear3DGCode();
lastRenderType = renderInfo.CurrentRenderType;
}
if (renderFeatures.Count > 0)
{
if (Is32Bit() && !GL.GlHasBufferObjects)
{
int maxFeaturesForThisSystem = 125000;
int totalFeaturesToRunder = 0;
bool cleanUnusedLayers = false;
// if on 32 bit system make sure we don't run out of memory rendering too many features
for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--)
{
if (totalFeaturesToRunder + renderFeatures[i].Count < maxFeaturesForThisSystem)
{
totalFeaturesToRunder += renderFeatures[i].Count;
}
else // don't render any of the layers below this and in fact remove them from memory if possible
{
renderInfo.startLayerIndex = i + 1;
cleanUnusedLayers = true;
break;
}
}
if (cleanUnusedLayers)
{
// no remove any layers that are set that we are not going to render
for (int removeIndex = 0; removeIndex < layerVertexBuffer.Count; removeIndex++)
{
if (removeIndex < renderInfo.StartLayerIndex || removeIndex >= renderInfo.EndLayerIndex)
{
if (layerVertexBuffer[removeIndex] != null)
{
layerVertexBuffer[removeIndex].Dispose();
layerVertexBuffer[removeIndex] = null;
}
}
}
}
}
for (int i = renderInfo.EndLayerIndex - 1; i >= renderInfo.StartLayerIndex; i--)
{
// If its the first render or we change what we are trying to render then create vertex data.
if (layerVertexBuffer[i] == null)
{
VectorPOD <ColorVertexData> colorVertexData = new VectorPOD <ColorVertexData>();
VectorPOD <int> vertexIndexArray = new VectorPOD <int>();
Create3DDataForLayer(i, colorVertexData, vertexIndexArray, renderInfo);
layerVertexBuffer[i] = new GCodeVertexBuffer();
layerVertexBuffer[i].SetVertexData(colorVertexData.Array);
layerVertexBuffer[i].SetIndexData(vertexIndexArray.Array);
}
}
GL.Disable(EnableCap.Texture2D);
GL.PushAttrib(AttribMask.EnableBit);
GL.DisableClientState(ArrayCap.TextureCoordArray);
GL.Enable(EnableCap.PolygonSmooth);
if (renderInfo.EndLayerIndex - 1 > renderInfo.StartLayerIndex)
{
for (int i = renderInfo.StartLayerIndex; i < renderInfo.EndLayerIndex - 1; i++)
{
int featuresOnLayer = renderFeatures[i].Count;
if (featuresOnLayer > 1)
{
layerVertexBuffer[i].renderRange(0, featureEndIndex[i][featuresOnLayer - 1]);
}
}
}
// draw the partial layer of end-1 from startRatio to endRatio
{
int layerIndex = renderInfo.EndLayerIndex - 1;
int featuresOnLayer = renderFeatures[layerIndex].Count;
int startFeature = (int)(featuresOnLayer * renderInfo.FeatureToStartOnRatio0To1 + .5);
startFeature = Math.Max(0, Math.Min(startFeature, featuresOnLayer));
int endFeature = (int)(featuresOnLayer * renderInfo.FeatureToEndOnRatio0To1 + .5);
endFeature = Math.Max(0, Math.Min(endFeature, featuresOnLayer));
// try to make sure we always draw at least one feature
if (endFeature <= startFeature)
{
endFeature = Math.Min(startFeature + 1, featuresOnLayer);
}
if (startFeature >= endFeature)
{
// This can only happen if the start and end are set to the last feature
// Try to set the start feature to one from the end
startFeature = Math.Max(endFeature - 1, 0);
}
if (endFeature > startFeature)
{
int ellementCount = featureEndIndex[layerIndex][endFeature - 1] - featureStartIndex[layerIndex][startFeature];
layerVertexBuffer[layerIndex].renderRange(featureStartIndex[layerIndex][startFeature], ellementCount);
}
}
GL.PopAttrib();
}
}
