Hardware basiertes Rendern von 3D Geometrie
Hardware erstellen und eine 3D-Geometrie auszahlen
Um eine 3D-Geometrie zu rendern, sind ein Shader, Puffer und ein Render zustand erforderlich. Keiner von ihnen kann ohne einander arbeiten.
- Puffer-Dreiecks listen sind einzelne Dreiecke, die in einem Array angegeben sind, das manchmal als Puffer bezeichnet wird. In einer Dreiecks liste wird jedes Dreieck einzeln angegeben. Punkte eines Dreiecks können mithilfe von Indizes gemeinsam genutzt werden, um die Datenmenge zu reduzieren, die an die Grafik hardware übergeben werden muss.
- Shader-Es definiert, wie man die Dreiecke aus dem Weltall in den Bildschirm raum transform iert und die endgültige Pixel farbe in der GPU-Seite berechnet
- Render Staaten-Es bietet Parameter für die GPU, um die Dreiecke in Pixel zu rastern.
Die OpenGL Shading Language (GLSL) ist die Standard-Schattierung sprache auf hoher Ebene für die OpenGL-Grafik API. Die InitRenderer-Methode in AssetBrowser/Controls/RenderView.cs-Datei unter der Demo-Anwendung (Name: Asset Browser) demonstriert die einfache Verwendung von GLSL mit Aspose.3D API. Es werden häufig drei Shader-Typen verwendet: Vertex-Shader, Fragment-Shader und Geometry-Shader.
Die GLSLSource-Klasse teilt dem Renderer mit, dass der Quellcode für die OpenGL-Shading-Sprache gilt und zu einer ShaderProgram-Klasse kompiliert werden kann. Die ShaderVariable-Klasse definiert die im Shader verwendeten Variablen. Die VariableSemantic-Klasse wird verwendet, um die semantische Aspose der Shader-Variable zu identifizieren. 3D Renderer bereitet automatisch Shader-Variablen werte vor, die von der Semantik abhängen.
Programmier probe für Shader
Dieses Code beispiel initial isiert Renderer und Shader für das Raster. Sie können das komplette Arbeits projekt dieses Beispiels von Hier herunter laden.
// For complete examples and data files, please go to https://github.com/aspose-3d/Aspose.3D-for-.NET
private void InitRenderer()
{
// Create a default camera, because it's required during the viewport's creation.
camera = new Camera();
Scene.RootNode.CreateChildNode("camera", camera);
// Create the renderer and render window from window's native handle
renderer = Renderer.CreateRenderer();
// Right now we only support native window handle from Microsoft Windows
// We'll support more platform on user's demand.
window = renderer.RenderFactory.CreateRenderWindow(new RenderParameters(), Handle);
// Create 4 viewports, the viewport's area is meanless here because we'll change it to the right area in the SetViewports later
viewports = new[]
{
window.CreateViewport(camera, Color.Gray, RelativeRectangle.FromScale(0, 0, 1, 1)),
window.CreateViewport(camera, Color.Gray, RelativeRectangle.FromScale(0, 0, 1, 1)),
window.CreateViewport(camera, Color.Gray, RelativeRectangle.FromScale(0, 0, 1, 1)),
window.CreateViewport(camera, Color.Gray, RelativeRectangle.FromScale(0, 0, 1, 1))
};
SetViewports(1);
//initialize shader for grid
GLSLSource src = new GLSLSource();
src.VertexShader = @"#version 330 core
layout (location = 0) in vec3 position;
uniform mat4 matWorldViewProj;
void main()
{
gl_Position = matWorldViewProj * vec4(position, 1.0f);
}";
src.FragmentShader = @"#version 330 core
out vec4 color;
void main()
{
color = vec4(1, 1, 1, 1);
}";
// Define the input format used by GLSL vertex shader the format is struct ControlPoint { FVector3 Position;}
VertexDeclaration fd = new VertexDeclaration();
fd.AddField(VertexFieldDataType.FVector3, VertexFieldSemantic.Position);
// Compile shader from GLSL source code and specify the vertex input format
gridShader = renderer.RenderFactory.CreateShaderProgram(src, fd);
// Connect GLSL uniform to renderer's internal variable
gridShader.Variables = new ShaderVariable[]
{
new ShaderVariable("matWorldViewProj", VariableSemantic.MatrixWorldViewProj)
};
SceneUpdated("");
}
Programmier probe für den Puffer-und Render zustand
Dieses Code beispiel initial isiert den Puffer-und Render zustand für das Raster.
// For complete examples and data files, please go to https://github.com/aspose-3d/Aspose.3D-for-.NET
class Grid : ManualEntity
{
public Grid(Renderer renderer, ShaderProgram shader)
{
// Render state for grid
RenderState = renderer.RenderFactory.CreateRenderState();
RenderState.DepthTest = true;
RenderState.DepthMask = true;
this.Shader = shader;
// Define the format of the control point to render the line
VertexDeclaration vd = new VertexDeclaration();
vd.AddField(VertexFieldDataType.FVector3, VertexFieldSemantic.Position);
// and create a vertex buffer for storing this kind of data
this.VertexBuffer = renderer.RenderFactory.CreateVertexBuffer(vd);
// Draw the primitive as lines
this.DrawOperation = DrawOperation.Lines;
this.RenderGroup = RenderQueueGroupId.Geometries;
List<FVector3> lines = new List<FVector3>();
for (int i = -10; i <= 10; i++)
{
// Draw - line
lines.Add(new FVector3(i, 0, -10));
lines.Add(new FVector3(i,0, 10));
// Draw | line
lines.Add(new FVector3(-10, 0, i));
lines.Add(new FVector3(10, 0, i));
}
// Put it to vertex buffer
VertexBuffer.LoadData(lines.ToArray());
}
}