Learn how to create a detailed React 3D Surface Mesh Chart using SciChart.js, and our High Performance JavaScript 3D Chart Library
import {
CameraController,
EDrawMeshAs,
GradientColorPalette,
HeatmapLegend,
MouseWheelZoomModifier3D,
NumberRange,
NumericAxis3D,
OrbitModifier3D,
ResetCamera3DModifier,
SciChart3DSurface,
SurfaceMeshRenderableSeries3D,
TooltipModifier3D,
UniformGridDataSeries3D,
Vector3,
zeroArray2D,
} from "scichart";
import { appTheme, createChartTheme } from "./appTheme";
// SCICHART CODE
export const drawExample = async (rootElement: string | HTMLDivElement) => {
// Create a SciChart3DSurface
const { sciChart3DSurface, wasmContext } = await SciChart3DSurface.create(rootElement, {
theme: appTheme.SciChartJsTheme,
});
// Create and position the camera in the 3D world
sciChart3DSurface.camera = new CameraController(wasmContext, {
position: new Vector3(-200, 150, 200),
target: new Vector3(0, 50, 0),
});
// Set the worlddimensions, which defines the Axis cube size
sciChart3DSurface.worldDimensions = new Vector3(200, 100, 200);
// Add an X,Y and Z Axis
sciChart3DSurface.xAxis = new NumericAxis3D(wasmContext, { axisTitle: "X Axis" });
sciChart3DSurface.yAxis = new NumericAxis3D(wasmContext, {
axisTitle: "Y Axis",
visibleRange: new NumberRange(0, 0.3),
});
sciChart3DSurface.zAxis = new NumericAxis3D(wasmContext, { axisTitle: "Z Axis" });
// Create a 2D array using the helper function zeroArray2D
// and fill this with data
const zSize = 25;
const xSize = 25;
const heightmapArray = zeroArray2D([zSize, xSize]);
for (let z = 0; z < zSize; z++) {
for (let x = 0; x < xSize; x++) {
const xVal = (x / xSize) * 25.0;
const zVal = (z / zSize) * 25.0;
const y = Math.sin(xVal * 0.2) / ((zVal + 1) * 2);
heightmapArray[z][x] = y;
}
}
// Create a UniformGridDataSeries3D
const dataSeries = new UniformGridDataSeries3D(wasmContext, {
yValues: heightmapArray,
xStep: 1,
zStep: 1,
dataSeriesName: "Uniform Surface Mesh",
});
// Create the color map
const colorMap = new GradientColorPalette(wasmContext, {
gradientStops: [
{ offset: 1, color: appTheme.VividPink },
{ offset: 0.9, color: appTheme.VividOrange },
{ offset: 0.7, color: appTheme.MutedRed },
{ offset: 0.5, color: appTheme.VividGreen },
{ offset: 0.3, color: appTheme.VividSkyBlue },
{ offset: 0.15, color: appTheme.Indigo },
{ offset: 0, color: appTheme.DarkIndigo },
],
});
// Finally, create a SurfaceMeshRenderableSeries3D and add to the chart
const series = new SurfaceMeshRenderableSeries3D(wasmContext, {
dataSeries,
minimum: 0,
maximum: 0.5,
opacity: 0.9,
cellHardnessFactor: 1.0,
shininess: 0,
lightingFactor: 0.0,
highlight: 1.0,
stroke: appTheme.VividBlue,
strokeThickness: 2.0,
contourStroke: appTheme.VividBlue,
contourInterval: 2,
contourOffset: 0,
contourStrokeThickness: 2,
drawSkirt: false,
drawMeshAs: EDrawMeshAs.SOLID_WIREFRAME,
meshColorPalette: colorMap,
isVisible: true,
});
sciChart3DSurface.renderableSeries.add(series);
// Optional: Add some interactivity modifiers
sciChart3DSurface.chartModifiers.add(new MouseWheelZoomModifier3D());
sciChart3DSurface.chartModifiers.add(new OrbitModifier3D());
sciChart3DSurface.chartModifiers.add(new ResetCamera3DModifier());
sciChart3DSurface.chartModifiers.add(new TooltipModifier3D({ tooltipContainerBackground: appTheme.PaleBlue }));
return { sciChartSurface: sciChart3DSurface, wasmContext };
};
export const drawHeatmapLegend = async (rootElement: string | HTMLDivElement) => {
const { heatmapLegend, wasmContext } = await HeatmapLegend.create(rootElement, {
theme: createChartTheme({
sciChartBackground: appTheme.DarkIndigo + "BB",
loadingAnimationBackground: appTheme.DarkIndigo + "BB",
}),
yAxisOptions: {
isInnerAxis: true,
labelStyle: {
fontSize: 12,
color: appTheme.ForegroundColor,
},
axisBorder: {
borderRight: 1,
color: appTheme.ForegroundColor + "77",
},
majorTickLineStyle: {
color: appTheme.ForegroundColor,
tickSize: 6,
strokeThickness: 1,
},
minorTickLineStyle: {
color: appTheme.ForegroundColor,
tickSize: 3,
strokeThickness: 1,
},
},
colorMap: {
minimum: 0,
maximum: 0.5,
gradientStops: [
{ offset: 1, color: appTheme.VividPink },
{ offset: 0.9, color: appTheme.VividOrange },
{ offset: 0.7, color: appTheme.MutedRed },
{ offset: 0.5, color: appTheme.VividGreen },
{ offset: 0.3, color: appTheme.VividSkyBlue },
{ offset: 0.15, color: appTheme.Indigo },
{ offset: 0, color: appTheme.DarkIndigo },
],
},
});
return { sciChartSurface: heatmapLegend.innerSciChartSurface.sciChartSurface };
};
This example demonstrates how to build an interactive SciChart.js 3D Surface Mesh Chart using the React framework. The implementation leverages the <SciChartReact/> component to initialize the chart by passing a custom drawExample function, creating a captivating 3D visualization from a heightmap array with an integrated heatmap legend.
The chart is created by instantiating a SciChart3DSurface with WebAssembly support, ensuring efficient performance. The drawExample function configures the 3D scene by setting up the camera using the CameraController, defining world dimensions, and creating numeric axes. A two-dimensional array of height values is generated using a mathematical sine function, and this data is used to produce a surface mesh via the UniformGridDataSeries3D and SurfaceMeshRenderableSeries3D classes. Interactive modifiers such as MouseWheelZoomModifier3D, OrbitModifier3D, ResetCamera3DModifier, and TooltipModifier3D are added to enhance user interaction. This approach follows best practices for initializing SciChart3DSurface in React and emphasizes efficient WebAssembly usage as detailed in the SciChart3DSurface API documentation.
GradientColorPalette to map colors onto the surface mesh, while the heatmap legend adds an extra layer of visual context.The React integration is handled seamlessly via the <SciChartReact/> component, which accepts functions like drawExample and drawHeatmapLegend as props. This pattern promotes modularity and reusability in React applications. Developers can refer to discussions on React component patterns and the SciChart React integration blog for deeper insights into component-based chart setups. Furthermore, leveraging WebAssembly for rendering provides significant performance benefits, a topic further explored in the context of JavaScript performance optimization. Overall, the implementation emphasizes interactive 3D visualization and efficient rendering in a modern React environment.










