Graphics New Features

Yuzhu Lu, Wolfram Research, Inc.

Join the Conversation #WolframTechConf

ABSTRACT

This presentation will present some new features and optimizations of Mathematica 2D and 3D Graphics language including new polygon syntax, local complex coordinates syntax, new polygon tessellation, volume rendering optimization, single pass depth peeling, SurefaceAppearance. It will also show some progress in Direct3D11, and Metal drawing layer and some possible benefits.

New Features and Optimizations: 
(Syntax might have some small changes in V12, please refer to the documentation)

New Polygon Syntaxes

Bounding Sphere

Raster3D New Options and Optimizations

Single Pass Depth Peeling

Polygon Optimizations and Benchmark

Surface Appearance

In Progress:

D3D11 and Metal Drawing Layer

List and Choice of graphic hardware

Build-In StereoScopic

More

New Polygon Syntaxes

Local Graphics Complex:
current syntax: GraphicsComplex[complexCoord, Primitive[index, opts]]
new syntax: Primitive[complexCoord, index, opts]

{Graphics[GraphicsComplex[{{0,0},{1,1},{0,1},{1,0}},Polygon[{1,2,3,4}]]],Graphics[Polygon[{{0,0},{1,1},{0,1},{1,0}},{1,2,3,4}]]}

{Graphics[GraphicsComplex[{{0,0},{1,1},{0,1},{1,0}},Polygon[{1,2,3,4}],VertexColors->{Yellow, Blue, Yellow,Red}]],Graphics[Polygon[{{0,0},{1,1},{0,1},{1,0}},{1,2,3,4},VertexColors->{Yellow, Blue, Yellow,Red}]]}

Primitives support local complex: 
Polygon, Line, Point, Arrow, Tube, BezierCurve, BSplineCurve, BSplineSurface, FilledCurve, JoinedCurve, Prism, Pyramid, Hexahedron, Tetrahedron, Cone, Sphere, Cylinder

Polygon with Hole Syntax:
Polygon[{boundary1->{hole1, hole2}.....}, opts]
Polygon[complexCoord, {boundaryIndex1->{holeIndex1, holeIndex2}.....}, opts]

{Graphics[{Polygon[{{0,0},{1,0},{1,1},{0.2,0.2},{0.8,0.2},{0.8,0.8},{0.9,0.1},{0.6,0.2},{0.9,0.3}},{1,2,3}->{{4,5,6},{7,8,9}}]}],Graphics3D[{Polygon[{{0,0,0},{1,0,0},{1,1,0},{0.2,0.2,0},{0.8,0.2,0},{0.8,0.8,0},{0.9,0.1,0},{0.6,0.2,0},{0.9,0.3,0}},{1,2,3}->{{4,5,6},{7,8,9}}]}]}

Choices when specify options for holes:

Graphics[{Polygon[{{{0,0},{1,0},{1,1}}->{{{0.2,0.2},{0.8,0.2},{0.8,0.8}},{{0.9,0.1},{0.6,0.2},{0.9,0.3}}}},VertexColors->{{Yellow,Green,Blue}->#}]}]&/@{Automatic, {{Red,Red,Red},{Red, Red,Red}}}

More Examples:

Graphics[{EdgeForm[{Red,Thickness[0.01]}],Polygon[{{0,0},{1,0},{1,1},{0.5,0.5},{0,1},{0.1,0.1},{0.9,0.1},{0.9,0.5},{0.5,0.25},{0.1,.5},{0.1,0.8},{0.1,0.6},{0.3,0.5},{0.9,0.8},{0.9,0.6},{0.7,0.5}},{1,2,3,4,5}->{{6,7,8,9,10},{11,12,13},{14,15,16}}]}]

starData={{(1/4) (-1-(Sqrt[5])),(Sqrt[(5/8)-((Sqrt[5])/8)])},{(1/4) (-1+(Sqrt[5])),-(Sqrt[(5/8)+((Sqrt[5])/8)])},{(1/4) (-1+(Sqrt[5])),(Sqrt[(5/8)+((Sqrt[5])/8)])},{(1/4) (-1-(Sqrt[5])),-(Sqrt[(5/8)-((Sqrt[5])/8)])},{1,0}};

Graphics[{Texture[ExampleData[{"TestImage","Mandrill"}]],Polygon[starData->Table[TranslationTransform[{0.5Cos[2Pi*i/5],0.5Sin[2Pi*i/5]}][0.15*starData],{i,1,5}],VertexTextureCoordinates->Automatic]}]

Bounding Sphere

Bounding Sphere:
syntax: SphericalRegion->Sphere[center, radius]

With SphericalRegion ->Sphere[c, r], It allows user specify a bounding sphere in user coordinates where c is the center and r is the radius. The radius will be respected in z direction and x, y direction will be scaled automatically in the camera space to get a spherical view scope. If c is specified explicitly, the ViewCenter option will be preceded. If Automatic is used for c, the specified ViewCenter will be used as the center of this bounding sphere. ViewAngle will also be preceded if a valid bounding sphere is specified.

Graphics3D[Sphere[{0,0,0}],Boxed->False,SphericalRegion->Sphere[{0,0,0},#],Epilog->Circle[Scaled[{0.5,0.5}],0.5]]&/@{1,3}

AnatomyPlot3D[Entity["AnatomicalStructure","LeftUpperLimb"],SphericalRegion->Entity["AnatomicalStructure","LeftHand"]["EnclosingSphere"],ViewCenter->{1,1,1}]

Raster3D New Options and Optimizations

MinSample:
syntax: Method->{“MinSample”->n}

Define the minimal volume dataset resample size and control the fuzziness

Graphics3D[{Raster3D[Reverse@CellularAutomaton[{14,{2,1},{1,1}},{{{1}},0},10],ColorFunction->(RGBColor[0.87,0.94,1,#]&),Method->{"FastRendering"->True,"VolumeLighting"->"EnhancedEdge","MinSample"->#,"InterpolateValues"->True}]},ImageSize->250]&/@{25,50,256}

Performance improvement combining Raster3D and other transparent Graphics3D if they do not overlap

Show[Import["ExampleData/CTengine.tiff","Image3D"], Graphics3D[{Opacity[.5], Sphere[{300,-50,150},40]}]]

DensityPlot3D[Sin[x]Cos[y]Sin[z],{x,y,z}∈Ball[{0,0,0},5],PlotTheme->"Marketing"]

Single Pass Depth Peeling

3D Transparency Rendering is Expensive

BSPTree---Split and Sort before Rendering

Multiple Pass Depth Peeling---Render One Layer Each Pass

Single Pass Depth Peeling---Rendering All Layers in One Pass

User can also set it with Option Inspector: Graphics Options / RenderingOptions / “3DRenderingMethod”

drg=Import["dragon.obj","GraphicsComplex"];

Graphics3D[{Blue,Opacity[0.5],EdgeForm[],drg},ImageSize->Large,Method->{"RotationOptimization"->False},BaseStyle->{RenderingOptions->{"3DRenderingMethod"->#,"3DRenderingEngine"->"OpenGL"}},PlotLabel->#]&/@{"BSPTree", "HardwareDepthPeeling","HardwareSinglePassDepthSorting"}

Grid[{{,"BSPTree","Multiple Pass Depth Peeling","Single Pass Depth Peeling"},{,"Not Responding","2 fps","10 fps"}},Frame->All,ItemStyle->{Automatic,Automatic,{{{1,1},{1,4}}->{Bold,16,RGBColor[0,0,0.8]}}}]

Polygon Optimizations and Benchmark

We are continually optimizing Polygon for both memory and performance

Plot3D[Sin[x+y^2],{x,-3,3},{y,-2,2},Mesh->None, MaxRecursion->0,PlotPoints->n]

Test on Window 64 bit with 16G RAM

Grid[{{Plot3D[Sin[x+y^2],{x,-3,3},{y,-2,2},Mesh->None, MaxRecursion->0],"V9","V10.4.1","V11.3","V12"},{PlotPoints,1500,2000,2000,2500},{"Rotation Performance","Not Responding","1.3 fps","3.0 fps","3.0 fps for 2000 PlotPoints"}},Frame->All,ItemStyle->{Automatic,Automatic,{{{1,1},{1,5}}->{Bold,16,RGBColor[0,0,0.8]}}}]

SurfaceAppearance

1. Customize Your Own Rendering With Shaders

2. Work with both Graphics and Graphics3D

3. Supported everywhere on all platforms with all drivers including Mesa
4. GLSL 1.2 standard

Association syntax

ShadowMap=\[LeftAssociation]
"Name"->"My Shadow Depth",
"Attributes"->\[LeftAssociation]"position"->"ATTRIB_VERTEX"\[RightAssociation],"Parameters"->\[LeftAssociation]"ShadowMatrix"->{"shadowMatrix",Automatic,"MATRIX4"}\[RightAssociation],"ShaderPrograms"->\[LeftAssociation]"GLFragmentProgram"->"void main() { gl_FragColor = vec4(gl_FragCoord.z, gl_FragCoord.z, gl_FragCoord.z, 1); }","GLVertexProgram"->"attribute vec4 position; uniform mat4 shadowMatrix; void main() { gl_Position = shadowMatrix * position; }"\[RightAssociation]
\[RightAssociation];

Dataset[ShadowMap]

Example 1: Shadow - Two Pass Rendering Method

ortho[l_,r_,b_,t_,zn_,zf_]:={{2/(r-l),0.0,0.0,0.0},{0.0,2/(t-b),0.0,0.0},{0.0,0.0,-2/(zf-zn),0.0},{(l+r)/(l-r),(t+b)/(b-t),(zn+zf)/(zn-zf),1.0}};
lookat[eyeX_,eyeY_,eyeZ_,objectX_,objectY_,objectZ_, upX_,upY_,upZ_]:=Module[{negEye={-eyeX,-eyeY,-eyeZ},n=Normalize[{eyeX-objectX,eyeY-objectY,eyeZ-objectZ}],up=Normalize[{upX,upY,upZ}],u=Normalize[Cross[Normalize@{upX,upY,upZ},Normalize@{eyeX-objectX,eyeY-objectY,eyeZ-objectZ}]]},v=Normalize[Cross[Normalize@{eyeX-objectX,eyeY-objectY,eyeZ-objectZ},u]];{Append[u,0],Append[v,0],Append[n,0],{Dot[negEye,u],Dot[negEye,v],Dot[negEye,n],1.0}}];

FE`Evaluate@Evaluate[FEPrivate`AddSurfaceAppearanceDefinition[ShadowMap]];

FE`Evaluate@Evaluate[FEPrivate`AddSurfaceAppearanceDefinition[\[LeftAssociation]
"Name"->"My Shadow",
"Attributes"->\[LeftAssociation]"position"->"ATTRIB_VERTEX","normal"->"ATTRIB_NORMAL"\[RightAssociation],"Parameters"->\[LeftAssociation]"WVPMatrix"->{"worldViewProjectionMatrix",Automatic,"WORLDVIEWPROJECTIONMATRIX"},"ShadowMatrix"->{"shadowMatrix",Automatic,"MATRIX4"},
"Texture2D"->{"texture",Automatic,"TEXTURE"},
"AmbientColor"->{"uAmbientColor",RGBColor[{0.5,0.5,0.5,1}],"COLOR"},
"LightingType"->{"uLightingType",0,"NUMBER"},
"LightingAtt"->{"uLightingAtt",1,"NUMBER"},"LightingDirection"->{"uLightingDirection",{1,1,1},"NUMBER3"},"DirectionalColor"->{"uDirectionalColor",RGBColor[{0.5,0.5,0.5,1}],"COLOR"}\[RightAssociation],"ShaderPrograms"->\[LeftAssociation]"GLFragmentProgram"->"varying vec4 colorVarying; varying vec4 shadowPosition; varying float cosTheta; uniform sampler2D texture; void main() { float visibility = 1.0; float bias = -0.005*tan(acos(cosTheta)); bias = clamp(bias, 0,0.005); vec3 sPos = shadowPosition.xyz / shadowPosition.w * 0.5 + 0.5; if(texture2D(texture, sPos.xy).z < sPos.z - 0.005) {visibility = 0.5;} gl_FragColor = colorVarying * visibility; gl_FragColor.a = colorVarying.a; }","GLVertexProgram"->"attribute vec4 position; attribute vec4 normal; uniform mat4 worldViewProjectionMatrix; uniform mat4 shadowMatrix; uniform vec4 uAmbientColor; uniform float uLightingType; uniform float uLightingAtt; uniform vec3 uLightingDirection; uniform vec4 uDirectionalColor; varying vec4 colorVarying; varying vec4 shadowPosition; varying float cosTheta;void main() { gl_Position = worldViewProjectionMatrix * position; shadowPosition = shadowMatrix * position; colorVarying = uAmbientColor; colorVarying.a = 1; cosTheta = dot(normalize(normal.xyz), normalize(uLightingDirection)); if(uLightingType < 0.5){float directionalLightWeighting = max(dot(normalize(normal.xyz), normalize(uLightingDirection)),0.01); colorVarying += uDirectionalColor * (directionalLightWeighting); }else{vec3 VP = normalize(uLightingDirection - position.xyz); float nDotVP = clamp( dot( VP, normalize(normal.xyz) ), 0.0, 1.0); if(nDotVP > 0.0) { float dist = length(uLightingDirection - position.xyz); float att = 1.0/(0.0065 * dist/uLightingAtt); colorVarying += uDirectionalColor * nDotVP * att; }} colorVarying = clamp(colorVarying, 0, 1);}"\[RightAssociation]
\[RightAssociation]]];

ShadowMap2[g_,plotRange_]:=Graphics3D[{System`SurfaceAppearance["My Shadow Depth","ShadowMatrix"->lookat[plotRange[[1,1]],plotRange[[2,2]], plotRange[[3,2]],0,0,0,0.0,1.0,0.0].ortho[2*plotRange[[1,1]],2*plotRange[[1,2]],2*plotRange[[2,1]],2*plotRange[[2,2]],4*plotRange[[3,1]],4*plotRange[[3,2]]]],{EdgeForm[None],White,g}},Boxed->False,PlotRange->plotRange];
ShadowedGraphics3D[g_,lightType_,lightColor_,plotRange_]:=Graphics3D[{System`SurfaceAppearance["My Shadow","DirectionalColor"->lightColor, "LightingType"->lightType,"LightingType"->plotRange[[3,2]],"LightingDirection"->{-plotRange[[1,1]],-plotRange[[2,2]], -plotRange[[3,2]]},"ShadowMatrix"->lookat[plotRange[[1,1]],plotRange[[2,2]], plotRange[[3,2]],0,0,0,0.0,1.0,0.0].ortho[2*plotRange[[1,1]],2*plotRange[[1,2]],2*plotRange[[2,1]],2*plotRange[[2,2]],4*plotRange[[3,1]],4*plotRange[[3,2]]]],{Texture[ShadowMap2[g,plotRange]],g/.Polygon[pts_,rest_]:>Polygon[pts,VertexTextureCoordinates->pts,rest]}}];

CylinderPolygon=Polygon[Table[{{Cos[angle], Sin[angle],-1},{Cos[angle], Sin[angle],1},{Cos[angle-Pi/15], Sin[angle-Pi/15],1},{Cos[angle-Pi/15], Sin[angle-Pi/15],-1}},{angle, 0, 2 Pi, Pi/15}],VertexNormals->Table[{{Cos[angle], Sin[angle],0},{Cos[angle], Sin[angle],0},{Cos[angle-Pi/15], Sin[angle-Pi/15],0},{Cos[angle-Pi/15], Sin[angle-Pi/15],0}},{angle, 0, 2 Pi, Pi/15}]];
ConePolygon=Polygon[Table[{{Cos[angle], Sin[angle],1},{Cos[angle+Pi/15], Sin[angle+Pi/15],1},{0, 0,3}},{angle, 0, 2 Pi, Pi/15}],VertexNormals->Table[{{Cos[angle], Sin[angle],0},{Cos[angle+Pi/15], Sin[angle+Pi/15],0},{0, 0,1}},{angle, 0, 2 Pi, Pi/15}]];
g3d={EdgeForm[None],CylinderPolygon,ConePolygon,Polygon[{{6,6,-2.1},{-6,6,-2.1},{-6,-6,-2.1},{6,-6,-2.1}},VertexNormals->{{0,0,1},{0,0,1},{0,0,1},{0,0,1}}],Polygon[{{2,2,-1},{-2,2,-1},{-2,-2,-1},{2,-2,-1}},VertexNormals->{{0,0,1},{0,0,1},{0,0,1},{0,0,1}}],Polygon[{{4,-4,-2},{4,-4,3},{4,4,3},{4,4,-2}},VertexNormals->{{1,0,0},{1,0,0},{1,0,0},{1,0,0}}]};

Manipulate[ShadowedGraphics3D[g3d,If[t==="Directional Light",0,1],Dynamic@c,{{-5,5},{-5,5},{-2.5,5}}
],{t,{"Directional Light", "Point Light"}},{c,GrayLevel[0.5]}]

ShadowMap2[g3d,{{-5,5},{-5,5},{-2.5,5}}]

ShadowedGraphics3D[Normal[ExampleData[{"Geometry3D","Galleon"},"GraphicsComplex"]],1,White,ExampleData[{"Geometry3D","Galleon"},"BoundingBox"]]

ShadowedGraphics3D[Normal[ExampleData[{"Geometry3D","Beethoven"},"GraphicsComplex"]],1,White,ExampleData[{"Geometry3D","Beethoven"},"BoundingBox"]]

ShadowedGraphics3D[Normal[ExampleData[{"Geometry3D","Cow"},"GraphicsComplex"]],1,White,ExampleData[{"Geometry3D","Cow"},"BoundingBox"]]

Example 2: Bump Mapping

FE`Evaluate@Evaluate[FEPrivate`AddSurfaceAppearanceDefinition[\[LeftAssociation]
"Name"->"My Bump Mapping",
"Attributes"->\[LeftAssociation]"position"->"ATTRIB_VERTEX","vertexTextureCoordIn"-> "ATTRIB_TEXTURECOORD"\[RightAssociation],"Parameters"->\[LeftAssociation]"WVPMatrix"->{"worldViewProjectionMatrix",Automatic,"WORLDVIEWPROJECTIONMATRIX"},"WVMatrix"->{"worldViewMatrix",Automatic,"WORLDVIEWMATRIX"},"WVITMatrix"->{"worldViewITMatrix",Automatic,"WORLDVIEWITMATRIX"},"VMatrix"->{"viewMatrix",Automatic,"VIEWMATRIX"},"Color"->{"color",Yellow,"COLOR"}, "SpecularColor"->{"specularColor",Automatic,"SPECULARCOLOR"},"EmissiveColor"->{"emissiveColor",Automatic,"EMISSIVECOLOR"},"SpecularExponent"->{"exponent",Automatic,"SPECULAREXPONENT"},"BackFrontFace"->{"backFrontFace",Automatic,"BACKFRONTFACE"},"AmbientLight"->{"ambientLight",Automatic,"AMBIENTLIGHT"},"NumLights"->{"numLights",Automatic,"NUMLIGHTS"},"LightPosition"->{"lightPosition",Automatic,"LIGHTPOSITION"},"LightDirection"->{"lightDirection",Automatic,"LIGHTDIRECTION"},"LightDiffuse"->{"lightDiffuse",Automatic,"LIGHTDIFFUSE"},"LightSpecular"->{"lightSpecular",Automatic,"LIGHTSPECULAR"},"LightAttenuation"->{"lightAttenuation",Automatic,"LIGHTATTENUATION"},"LightInfo"->{"lightInfo",Automatic,"LIGHTINFO"}\[RightAssociation],"ShaderPrograms"->\[LeftAssociation]"GLFragmentProgram"->"uniform mat4 worldViewProjectionMatrix; uniform mat4 worldViewMatrix; uniform mat4 worldViewITMatrix; uniform mat4 viewMatrix; uniform vec4 color;  uniform vec4 specularColor; uniform vec4 emissiveColor; uniform float exponent; uniform float backFrontFace; uniform vec4 ambientLight; uniform int  numLights; uniform vec4 lightPosition[10]; uniform vec4 lightDirection[10]; uniform vec4 lightDiffuse[10]; uniform vec4 lightSpecular[10]; uniform vec4 lightAttenuation[10]; uniform vec4 lightInfo[10]; uniform sampler2D texture; varying vec4 TransformedPosition; varying vec4 texCoordOut; void main() { vec4 normal = 2*texture2D(texture, texCoordOut.xy)-1; normal=normalize(normal); vec4 TransformedNormal = -worldViewITMatrix * normal; vec3 hnormal = backFrontFace * normalize(TransformedNormal.xyz); vec4 vColor = vec4(0,0,0,0); vec4 vSpecular = vec4(0,0,0,0); vec4 diffuseColor = color; vec3 VP; vec3 vHalf; float nDotVP; float nDotHV; float pf; vColor += ambientLight * color; for(int i = 0; i < numLights; i++) { /*          Desc: Directional light computation           */ if(lightInfo[i].x > 2.5) {  VP = -normalize(vec4(viewMatrix * lightDirection[i]).xyz); nDotVP = clamp( dot( VP, hnormal ), 0.0, 1.0); vHalf = normalize(-normalize(TransformedPosition.xyz) + VP); vColor += lightDiffuse[i] * diffuseColor * nDotVP; nDotHV = max( 0.0, dot( hnormal, vHalf ) ); if( nDotVP <= 0.0 ) { pf = 0.0; } else { pf = pow( nDotHV, exponent ); } vSpecular += lightSpecular[i] * specularColor * pf; } /*          Desc: Spot light computation         */ else if(lightInfo[i].x > 1.5) { VP = normalize(vec4(viewMatrix * lightPosition[i]).xyz -TransformedPosition.xyz); nDotVP = clamp( dot(VP, hnormal ), 0.0, 1.0); if(nDotVP > 0.0) { vec3 VP2 = -normalize(vec4(viewMatrix * lightDirection[i]).xyz); float spotEffect = -dot(VP, VP2); if(spotEffect > lightInfo[i].z) { spotEffect = pow(spotEffect, lightInfo[i].w); float dist = length(vec4(viewMatrix * lightPosition[i]).xyz -TransformedPosition.xyz); vHalf = normalize(-normalize(TransformedPosition.xyz) + VP); float att = spotEffect/(lightAttenuation[i].x + lightAttenuation[i].y * dist + lightAttenuation[i].z * dist * dist); vColor += lightDiffuse[i] * diffuseColor * nDotVP * att; nDotHV = max( 0.0, dot( hnormal, vHalf ) ); pf = pow( nDotHV, exponent ); vSpecular += lightSpecular[i] * specularColor * pf * att; } } } /*          Desc: Point light computation           */else if(lightInfo[i].x > 0.5) { VP = normalize(vec4(viewMatrix * lightPosition[i]).xyz -TransformedPosition.xyz); nDotVP = clamp( dot( VP, hnormal ), 0.0, 1.0); if(nDotVP > 0.0) { float dist = length(vec4(viewMatrix * lightPosition[i]).xyz -TransformedPosition.xyz); vHalf = normalize(-normalize(TransformedPosition.xyz) + VP); float att = 1.0/(lightAttenuation[i].x + lightAttenuation[i].y * dist + lightAttenuation[i].z * dist * dist); vColor += lightDiffuse[i] * diffuseColor * nDotVP * att; nDotHV = max( 0.0, dot( hnormal, vHalf ) ); pf = pow( nDotHV, exponent ); vSpecular += lightSpecular[i] * specularColor * pf * att; } }  } vec4 color0 = clamp(vColor + emissiveColor, 0.0, 1.0 ); vec4 color1 = clamp(vSpecular, 0.0, 1.0); gl_FragColor = color0 + color1; gl_FragColor.a = diffuseColor.a;}","GLVertexProgram"->"attribute vec4 position; attribute vec4 vertexTextureCoordIn; uniform mat4 worldViewProjectionMatrix; uniform mat4 worldViewMatrix; uniform mat4 worldViewITMatrix; uniform mat4 viewMatrix; varying vec4 TransformedPosition; varying vec4 texCoordOut; void main() { gl_Position = worldViewProjectionMatrix * position; TransformedPosition = worldViewMatrix * position; texCoordOut = vertexTextureCoordIn;}"\[RightAssociation]
\[RightAssociation]]];

v={{-1,-1,-1},{1,-1,-1},{1,1,-1},{-1,1,-1},{-1,-1,1},{1,-1,1},{1,1,1},{-1,1,1}};
i={{1,2,3,4},{1,2,6,5},{2,3,7,6},{3,4,8,7},{4,1,5,8},{5,6,7,8}};
t={{0,0},{0,1},{1,1},{1,0}};

Manipulate[Graphics3D[{Texture[ImageData@],Specularity[White,50],System`SurfaceAppearance["My Bump Mapping","Color"->Dynamic@c],GraphicsComplex[v,Polygon[i,VertexTextureCoordinates->{t,t,t,t,t,t}]]}],{c,White}]

Manipulate[Graphics3D[{Texture[ImageData@],Specularity[White,20],System`SurfaceAppearance["My Bump Mapping","Color"->Dynamic@c],GraphicsComplex[v,Polygon[i,VertexTextureCoordinates->{t,t,t,t,t,t}]]},Lighting->{{"Point",White,{1.5,0,0}}}],{c,White}]

List and Choice of graphic hardware

We are working on Newer Drawing Layers on both Windows and Mac: Direct3D11 and Metal

User can choose graphic hardware for rendering through “PreferredGPU” option

It will work on both Windows and Mac

SystemInformation will show more informations

Build-In Stereoscopic

Build-In Stereoscopic support for Direct3D11

We are doing the same way as Unity does on Windows

Be Aware:

1. Work with all 3D Graphics
2. Windows Only
3. Direct3D 11.1 Support
4. Hardware Requirements: NVidia Desktop hardware tested

More

Text and Tick Labels will look much better on Windows

Fast Depth peeling will be supported on both Direct3D11 and Metal