protected internal virtual void setUniformsSamplers(IRenderingEngine re, int shaderProgram)
{
re.setUniform(Uniforms.clut.getId(shaderProgram), clut);
re.setUniform(Uniforms.tex.getId(shaderProgram), tex);
re.setUniform(Uniforms.utex.getId(shaderProgram), utex);
re.setUniform(Uniforms.fbTex.getId(shaderProgram), fbTex);
}
private string CreateRows(object source, IRenderingEngine engine)
{
var props = source.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
var rows = new StringBuilder();
foreach (var propertyInfo in props)
{
var childRenderer = engine.TryFindRenderer(propertyInfo.PropertyType);
var childValue = propertyInfo.GetValue(source);
var childRendering = childRenderer.Render(childValue, engine);
var row = $@"<tr><td>{propertyInfo.Name}</td><td>{childRendering.Content}</td></tr>";
rows.AppendLine(row);
}
var fields = source.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (var fieldInfo in fields)
{
var childRenderer = engine.TryFindRenderer(fieldInfo.FieldType);
var childValue = fieldInfo.GetValue(source);
var childRendering = childRenderer.Render(childValue, engine);
var row = $@"<tr><td>{fieldInfo.Name}</td><td>{childRendering.Content}</td></tr>";
rows.AppendLine(row);
}
return(rows.ToString());
}
public virtual void bind(IRenderingEngine re)
{
if (bufferId == -1)
{
bufferId = re.genBuffer();
}
re.bindBuffer(bufferTarget, bufferId);
}
public IRendering Render(object source, IRenderingEngine engine = null)
{
var sourceType = source.GetType();
var isStructured = RendererUtilities.IsStructured(sourceType);
return(isStructured ? RenderObject(source, engine) : new PlainTextRendering(source?.ToString()));
}
public virtual int getTextureId(IRenderingEngine re)
{
if (textureId == -1)
{
textureId = re.genTexture();
}
return(textureId);
}
public virtual void reset(IRenderingEngine re)
{
foreach (Texture texture in cache.values())
{
texture.deleteTexture(re);
}
cache.clear();
resetTextureAlreadyHashed();
}
public IRendering RenderObject(object source, IRenderingEngine engine = null)
{
var rows = CreateRows(source, engine);
var table = $@"<table>
{rows}
</table>";
return(new HtmlRendering(table));
}
public virtual void reset(IRenderingEngine re)
{
foreach (GETexture geTexture in geTextures.Values)
{
geTexture.delete(re);
}
geTextures.Clear();
}
public virtual void deleteTexture(IRenderingEngine re)
{
if (textureId != -1)
{
re.deleteTexture(textureId);
textureId = -1;
}
Loaded = false;
}
public virtual void setProgramId(IRenderingEngine re, int programId)
{
this.programId = programId;
shaderAttribWeights1 = re.getAttribLocation(programId, REShader.attributeNameWeights1);
shaderAttribWeights2 = re.getAttribLocation(programId, REShader.attributeNameWeights2);
shaderAttribPosition = re.getAttribLocation(programId, REShader.attributeNamePosition);
shaderAttribNormal = re.getAttribLocation(programId, REShader.attributeNameNormal);
shaderAttribColor = re.getAttribLocation(programId, REShader.attributeNameColor);
shaderAttribTexture = re.getAttribLocation(programId, REShader.attributeNameTexture);
}
/// <summary>
/// Create a rendering engine to be used when the HLE modules have not yet
/// been started.
/// </summary>
/// <returns> the initial rendering engine </returns>
public static IRenderingEngine createInitialRenderingEngine()
{
IRenderingEngine re = RenderingEngineLwjgl.newInstance();
if (enableDebugProxy)
{
re = new DebugProxy(re);
}
return(re);
}
public virtual VertexArray getVertexArray(IRenderingEngine re, int vtype, VertexBuffer vertexBuffer, int address, int stride)
{
statistics.start();
int fastLookupKey = getFastLookupKey(vtype, vertexBuffer, address, stride);
VertexArray vertexArray = fastLookup[fastLookupKey];
if (vertexArray != null)
{
if (vertexArray.isMatching(vtype, vertexBuffer, address, stride))
{
statistics.end();
return(vertexArray);
}
}
bool first = true;
//JAVA TO C# CONVERTER WARNING: Unlike Java's ListIterator, enumerators in .NET do not allow altering the collection:
for (IEnumerator <VertexArray> lit = vertexArrays.GetEnumerator(); lit.MoveNext();)
{
vertexArray = lit.Current;
if (vertexArray.isMatching(vtype, vertexBuffer, address, stride))
{
if (!first)
{
// Move the VertexArray to the head of the list
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
lit.remove();
vertexArrays.Insert(0, vertexArray);
}
fastLookup[fastLookupKey] = vertexArray;
statistics.end();
return(vertexArray);
}
first = false;
}
vertexArray = new VertexArray(vtype, vertexBuffer, stride);
vertexArrays.Insert(0, vertexArray);
if (vertexArrays.Count > maxSize)
{
VertexArray toBeDeleted = vertexArrays.Remove(vertexArrays.Count - 1);
if (toBeDeleted != null)
{
toBeDeleted.delete(re);
}
}
statistics.end();
return(vertexArray);
}
public virtual void reset(IRenderingEngine re)
{
lock (this)
{
foreach (VertexInfo vertexInfo in cache.values())
{
vertexInfo.deleteVertex(re);
}
cache.clear();
}
}
public virtual GETexture getGEIndexedTexture(IRenderingEngine re, GETexture baseGETexture, int address, int bufferWidth, int width, int height, int pixelFormat)
{
GETexture geTexture = checkGETexture(address, bufferWidth, width, height, pixelFormat);
if (geTexture == null)
{
long?key = getKey(address, bufferWidth, width, height, pixelFormat);
geTexture = new GEIndexedTexture(baseGETexture, address, bufferWidth, width, height, pixelFormat);
geTextures[key] = geTexture;
}
return(geTexture);
}
public virtual void reset(IRenderingEngine re)
{
lock (this)
{
//JAVA TO C# CONVERTER WARNING: Unlike Java's ListIterator, enumerators in .NET do not allow altering the collection:
for (IEnumerator <VertexBuffer> lit = vertexBuffers.GetEnumerator(); lit.MoveNext();)
{
VertexBuffer vertexBuffer = lit.Current;
vertexBuffer.delete(re);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
lit.remove();
}
}
}
public static IREBufferManager createBufferManager(IRenderingEngine re)
{
IREBufferManager bufferManager;
if (BufferManagerVBO.useVBO(re))
{
bufferManager = new BufferManagerVBO();
}
else
{
bufferManager = new BufferManagerDefault();
}
return(bufferManager);
}
public virtual void onVertexBufferDeleted(IRenderingEngine re, VertexBuffer vertexBuffer)
{
// Delete all the VertexArray using the deleted VertexBuffer
//JAVA TO C# CONVERTER WARNING: Unlike Java's ListIterator, enumerators in .NET do not allow altering the collection:
for (IEnumerator <VertexArray> lit = vertexArrays.GetEnumerator(); lit.MoveNext();)
{
VertexArray vertexArray = lit.Current;
if (vertexArray.VertexBuffer == vertexBuffer)
{
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
lit.remove();
vertexArray.delete(re);
}
}
}
public override void setUniforms(IRenderingEngine re, int shaderProgram)
{
if (startUpdate < endUpdate)
{
re.bindBuffer(IRenderingEngine_Fields.RE_UNIFORM_BUFFER, buffer);
data.position(startUpdate);
re.setBufferSubData(IRenderingEngine_Fields.RE_UNIFORM_BUFFER, startUpdate, endUpdate - startUpdate, data);
data.limit(data.capacity());
startUpdate = bufferSize;
endUpdate = 0;
}
// Samplers can only be passed as uniforms
setUniformsSamplers(re, shaderProgram);
}
public virtual void delete(IRenderingEngine re)
{
lock (this)
{
if (bufferId != -1)
{
re.deleteBuffer(bufferId);
bufferId = -1;
}
bufferLength = 0;
bufferAddress = 0;
stride = 0;
cachedBuffer = null;
cachedMemory = null;
}
}
public IRendering RenderObject(object source, IRenderingEngine engine = null)
{
try
{
var rows = CreateRows(source, engine);
var table = $@"<table>
{rows}
</table>";
return(new HtmlRendering(table));
}
catch (Exception)
{
return(new PlainTextRendering(source?.ToString()));
}
}
public virtual void addTexture(IRenderingEngine re, Texture texture)
{
int? key = getKey(texture.Addr, texture.ClutAddr, texture.ClutStart, texture.ClutMode);
Texture previousTexture = cache.get(key);
if (previousTexture != null)
{
previousTexture.deleteTexture(re);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method:
vramTextures.remove(previousTexture);
}
else
{
// Check if the cache is not growing too large
if (cache.size() >= cacheMaxSize)
{
// Remove the LRU cache entry
IEnumerator <KeyValuePair <int, Texture> > it = cache.entrySet().GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (it.hasNext())
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
KeyValuePair <int, Texture> entry = it.next();
Texture lruTexture = entry.Value;
lruTexture.deleteTexture(re);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method:
vramTextures.remove(lruTexture);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
it.remove();
statistics.entriesRemoved++;
}
}
}
cache.put(key, texture);
if (isVramTexture(texture))
{
vramTextures.AddLast(texture);
}
if (cache.size() > statistics.maxSizeUsed)
{
statistics.maxSizeUsed = cache.size();
}
}
public virtual GETexture getGETexture(IRenderingEngine re, int address, int bufferWidth, int width, int height, int pixelFormat, bool useViewportResize)
{
int gePixelFormat = getTexturePixelFormat(pixelFormat);
GETexture geTexture = checkGETexturePSM8888(address, bufferWidth, width, height, pixelFormat);
if (geTexture == null)
{
geTexture = checkGETexture(address, bufferWidth, width, height, pixelFormat);
}
if (geTexture == null)
{
long?key = getKey(address, bufferWidth, width, height, pixelFormat);
geTexture = new GETexture(address, bufferWidth, width, height, gePixelFormat, useViewportResize);
geTextures[key] = geTexture;
}
return(geTexture);
}
public virtual void addVertex(IRenderingEngine re, VertexInfo vertexInfo, int numberOfVertex, float[][] boneMatrix, int numberOfWeightsForShader)
{
lock (this)
{
int? key = getKey(vertexInfo);
VertexInfo previousVertex = cache.get(key);
if (previousVertex != null)
{
vertexInfo.reuseCachedBuffer(previousVertex);
previousVertex.deleteVertex(re);
}
else
{
// Check if the cache is not growing too large
if (cache.size() >= cacheMaxSize)
{
// Remove the LRU cache entry
IEnumerator <KeyValuePair <int, VertexInfo> > it = cache.entrySet().GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (it.hasNext())
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
KeyValuePair <int, VertexInfo> entry = it.next();
entry.Value.deleteVertex(re);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
it.remove();
statistics.entriesRemoved++;
}
}
}
vertexInfo.prepareForCache(this, numberOfVertex, boneMatrix, numberOfWeightsForShader);
cache.put(key, vertexInfo);
if (cache.size() > statistics.maxSizeUsed)
{
statistics.maxSizeUsed = cache.size();
}
}
}
public virtual void deleteVramTextures(IRenderingEngine re, int addr, int Length)
{
//JAVA TO C# CONVERTER WARNING: Unlike Java's ListIterator, enumerators in .NET do not allow altering the collection:
for (IEnumerator <Texture> lit = vramTextures.GetEnumerator(); lit.MoveNext();)
{
Texture texture = lit.Current;
if (texture.isInsideMemory(addr, addr + Length))
{
//if (log.DebugEnabled)
{
Console.WriteLine(string.Format("Delete VRAM texture inside GE {0}", texture.ToString()));
}
texture.deleteTexture(re);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
lit.remove();
int?key = getKey(texture.Addr, texture.ClutAddr, texture.ClutStart, texture.ClutMode);
cache.remove(key);
statistics.entriesRemoved++;
}
}
}
public IRendering Render(object source, IRenderingEngine engine = null)
{
switch (source)
{
case IList sequence:
var sourceType = RendererUtilities.GetSequenceElementTypeOrKeyValuePairValueType(sequence);
var accessors = RendererUtilities.GetAccessors(sourceType).ToList();
var keyValueList = sequence.OfType <object>()
.Select((v, i) => new KeyValuePair <object, object>(i, v));
var headers = RendererUtilities.CreateTableHeaders(accessors, true);
var rows = RendererUtilities.CreateTableRowsFromValues(accessors, keyValueList, engine);
var table = $@"<table>
{headers}
{rows}
</table>";
return(new HtmlRendering(table));
default:
throw new ArgumentOutOfRangeException($"Sequence type {source.GetType()} not supported ");
}
}
private void checkDirty(IRenderingEngine re)
{
if (reloadBufferDataPending)
{
bind(re);
position(bufferAddress);
re.setBufferData(bufferTarget, cachedBuffer.remaining(), cachedBuffer, bufferUsage);
reloadBufferDataPending = false;
numberDirtyRanges = 0;
}
else if (numberDirtyRanges > 0)
{
bind(re);
for (int i = 0; i < numberDirtyRanges; i++)
{
position(dirtyRanges[i].address);
re.setBufferSubData(bufferTarget, cachedBuffer.position(), dirtyRanges[i].Length, cachedBuffer);
}
numberDirtyRanges = 0;
}
}
private static void CreateTableRow(IEnumerable <MemberInfo> memberInfos, IRenderingEngine engine, object element,
IRendering defaultRendering, StringBuilder rowsBuffer)
{
if (memberInfos?.Any() != false)
{
foreach (var memberInfo in memberInfos)
{
IRendering childRendering = null;
switch (memberInfo)
{
case PropertyInfo propertyInfo:
{
var childRenderer = engine.TryFindRenderer(propertyInfo.PropertyType);
var childValue = propertyInfo.GetValue(element);
childRendering = childValue == null ? defaultRendering : childRenderer.Render(childValue, engine);
}
break;
case FieldInfo fieldInfo:
{
var childRenderer = engine.TryFindRenderer(fieldInfo.FieldType);
var childValue = fieldInfo.GetValue(element);
childRendering = childValue == null ? defaultRendering : childRenderer.Render(childValue, engine);
}
break;
}
var row = $"\t\t<td>{childRendering?.Content ?? string.Empty}</td>";
rowsBuffer.AppendLine(row);
}
}
else
{
var childRenderer = engine.TryFindRenderer(element.GetType());
var childRendering = childRenderer.Render(element, engine);
rowsBuffer.AppendLine($"\t\t<td>{childRendering.Content}</td>");
}
}
public IRendering Render(object source, IRenderingEngine engine = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
switch (source)
{
case IEnumerable sequence:
var sourceType = RendererUtilities.GetSequenceElementTypeOrKeyValuePairValueType(sequence);
var accessors = RendererUtilities.GetAccessors(sourceType).ToList();
var headers = RendererUtilities.CreateTableHeaders(accessors, false);
var rows = RendererUtilities.CreateTableRowsFromValues(accessors, sequence, engine);
var table = $@"<table>
{headers}
{rows}
</table>";
return(new HtmlRendering(table));
default:
throw new ArgumentOutOfRangeException($"Sequence type {source.GetType()} not supported ");
}
}
public CheckErrorsProxy(IRenderingEngine proxy) : base(proxy)
{
}
public static string CreateTableRowsFromValues(IEnumerable <MemberInfo> memberInfos, IEnumerable <KeyValuePair <object, object> > source, IRenderingEngine engine,
bool emptyFirstCell = false)
{
var nullRendering = new PlainTextRendering("null");
var rowsBuffer = new StringBuilder();
foreach (var(key, element) in source.Select(e => (e.Key, e.Value)))
{
rowsBuffer.AppendLine("\t<tr>");
if (emptyFirstCell)
{
rowsBuffer.AppendLine("\t\t<td></td>");
}
var keyRenderer = engine.TryFindRenderer(key.GetType());
var keyRendering = keyRenderer.Render(key, engine);
rowsBuffer.AppendLine($"\t\t<td>{keyRendering?.Content ?? string.Empty}</td>");
CreateTableRow(memberInfos, engine, element, nullRendering, rowsBuffer);
rowsBuffer.AppendLine("\t</tr>");
}
return(rowsBuffer.ToString());
}
