diff --git a/src/mol-geo/geometry/geometry.ts b/src/mol-geo/geometry/geometry.ts
index 4663f7286ab47426b7cc5f3566332c7ed07e9ee0..98393c607c2ea411a3a358fb9ab592225681d940 100644
--- a/src/mol-geo/geometry/geometry.ts
+++ b/src/mol-geo/geometry/geometry.ts
@@ -21,7 +21,7 @@ import { TransformData } from './transform-data';
import { Theme } from 'mol-theme/theme';
import { RenderObjectValuesType } from 'mol-gl/render-object';
import { ValueOf } from 'mol-util/type-helpers';
-import { Isosurface } from './isosurface/isosurface';
+import { TextureMesh } from './texture-mesh/texture-mesh';
export type GeometryKindType = {
'mesh': Mesh,
@@ -30,7 +30,7 @@ export type GeometryKindType = {
'text': Text,
'lines': Lines,
'direct-volume': DirectVolume,
- 'isosurface': Isosurface,
+ 'texture-mesh': TextureMesh,
}
export type GeometryKindParams = {
'mesh': Mesh.Params,
@@ -39,7 +39,7 @@ export type GeometryKindParams = {
'text': Text.Params,
'lines': Lines.Params,
'direct-volume': DirectVolume.Params,
- 'isosurface': Isosurface.Params,
+ 'texture-mesh': TextureMesh.Params,
}
export type GeometryKind = keyof GeometryKindType
export type Geometry = ValueOf<GeometryKindType>
@@ -66,7 +66,7 @@ export namespace Geometry {
case 'text': return geometry.charCount * 2 * 3
case 'lines': return geometry.lineCount * 2 * 3
case 'direct-volume': return 12 * 3
- case 'isosurface': return geometry.vertexCount.ref.value * 3
+ case 'texture-mesh': return geometry.vertexCount.ref.value * 3
}
}
@@ -80,7 +80,7 @@ export namespace Geometry {
return getDrawCount(geometry) === 0 ? 0 : (arrayMax(geometry.groupBuffer.ref.value) + 1)
case 'direct-volume':
return 1
- case 'isosurface':
+ case 'texture-mesh':
return geometry.groupCount.ref.value
}
}
@@ -94,7 +94,7 @@ export namespace Geometry {
case 'text': return Text.Utils as any
case 'lines': return Lines.Utils as any
case 'direct-volume': return DirectVolume.Utils as any
- case 'isosurface': return Isosurface.Utils as any
+ case 'texture-mesh': return TextureMesh.Utils as any
}
throw new Error('unknown geometry kind')
}
diff --git a/src/mol-geo/geometry/isosurface/isosurface.ts b/src/mol-geo/geometry/texture-mesh/texture-mesh.ts
similarity index 69%
rename from src/mol-geo/geometry/isosurface/isosurface.ts
rename to src/mol-geo/geometry/texture-mesh/texture-mesh.ts
index c55b9388dac18d67012f9bab0c7aaa837012a3f8..0eeaa87861f345df3a258810e9488bcd45fe65cc 100644
--- a/src/mol-geo/geometry/isosurface/isosurface.ts
+++ b/src/mol-geo/geometry/texture-mesh/texture-mesh.ts
@@ -17,18 +17,18 @@ import { Color } from 'mol-util/color';
import { BaseGeometry } from '../base';
import { createEmptyOverpaint } from '../overpaint-data';
import { createEmptyTransparency } from '../transparency-data';
-import { IsosurfaceValues } from 'mol-gl/renderable/isosurface';
+import { TextureMeshValues } from 'mol-gl/renderable/texture-mesh';
import { calculateTransformBoundingSphere } from 'mol-gl/renderable/util';
import { Texture } from 'mol-gl/webgl/texture';
import { Vec2 } from 'mol-math/linear-algebra';
import { fillSerial } from 'mol-util/array';
-export interface Isosurface {
- readonly kind: 'isosurface',
+export interface TextureMesh {
+ readonly kind: 'texture-mesh',
- /** Number of vertices in the isosurface */
+ /** Number of vertices in the texture-mesh */
readonly vertexCount: ValueCell<number>,
- /** Number of groups in the isosurface */
+ /** Number of groups in the texture-mesh */
readonly groupCount: ValueCell<number>,
readonly geoTextureDim: ValueCell<Vec2>,
@@ -39,20 +39,20 @@ export interface Isosurface {
readonly boundingSphere: ValueCell<Sphere3D>,
}
-export namespace Isosurface {
- export function create(vertexCount: number, groupCount: number, vertexGroupTexture: Texture, normalTexture: Texture, boundingSphere: Sphere3D, isosurface?: Isosurface): Isosurface {
+export namespace TextureMesh {
+ export function create(vertexCount: number, groupCount: number, vertexGroupTexture: Texture, normalTexture: Texture, boundingSphere: Sphere3D, textureMesh?: TextureMesh): TextureMesh {
const { width, height } = vertexGroupTexture
- if (isosurface) {
- ValueCell.update(isosurface.vertexCount, vertexCount)
- ValueCell.update(isosurface.groupCount, groupCount)
- ValueCell.update(isosurface.geoTextureDim, Vec2.set(isosurface.geoTextureDim.ref.value, width, height))
- ValueCell.update(isosurface.vertexGroupTexture, vertexGroupTexture)
- ValueCell.update(isosurface.normalTexture, normalTexture)
- ValueCell.update(isosurface.boundingSphere, boundingSphere)
- return isosurface
+ if (textureMesh) {
+ ValueCell.update(textureMesh.vertexCount, vertexCount)
+ ValueCell.update(textureMesh.groupCount, groupCount)
+ ValueCell.update(textureMesh.geoTextureDim, Vec2.set(textureMesh.geoTextureDim.ref.value, width, height))
+ ValueCell.update(textureMesh.vertexGroupTexture, vertexGroupTexture)
+ ValueCell.update(textureMesh.normalTexture, normalTexture)
+ ValueCell.update(textureMesh.boundingSphere, boundingSphere)
+ return textureMesh
} else {
return {
- kind: 'isosurface',
+ kind: 'texture-mesh',
vertexCount: ValueCell.create(vertexCount),
groupCount: ValueCell.create(groupCount),
geoTextureDim: ValueCell.create(Vec2.create(width, height)),
@@ -63,8 +63,8 @@ export namespace Isosurface {
}
}
- export function createEmpty(isosurface?: Isosurface): Isosurface {
- return {} as Isosurface // TODO
+ export function createEmpty(textureMesh?: TextureMesh): TextureMesh {
+ return {} as TextureMesh // TODO
}
export const Params = {
@@ -75,7 +75,7 @@ export namespace Isosurface {
}
export type Params = typeof Params
- export const Utils: GeometryUtils<Isosurface, Params> = {
+ export const Utils: GeometryUtils<TextureMesh, Params> = {
Params,
createEmpty,
createValues,
@@ -86,26 +86,26 @@ export namespace Isosurface {
updateRenderableState: BaseGeometry.updateRenderableState
}
- function createValues(isosurface: Isosurface, transform: TransformData, locationIt: LocationIterator, theme: Theme, props: PD.Values<Params>): IsosurfaceValues {
+ function createValues(textureMesh: TextureMesh, transform: TransformData, locationIt: LocationIterator, theme: Theme, props: PD.Values<Params>): TextureMeshValues {
const { instanceCount, groupCount } = locationIt
const color = createColors(locationIt, theme.color)
const marker = createMarkers(instanceCount * groupCount)
const overpaint = createEmptyOverpaint()
const transparency = createEmptyTransparency()
- const counts = { drawCount: isosurface.vertexCount.ref.value, groupCount, instanceCount }
+ const counts = { drawCount: textureMesh.vertexCount.ref.value, groupCount, instanceCount }
- const transformBoundingSphere = calculateTransformBoundingSphere(isosurface.boundingSphere.ref.value, transform.aTransform.ref.value, transform.instanceCount.ref.value)
+ const transformBoundingSphere = calculateTransformBoundingSphere(textureMesh.boundingSphere.ref.value, transform.aTransform.ref.value, transform.instanceCount.ref.value)
return {
- uGeoTexDim: isosurface.geoTextureDim,
- tPositionGroup: isosurface.vertexGroupTexture,
- tNormal: isosurface.normalTexture,
+ uGeoTexDim: textureMesh.geoTextureDim,
+ tPositionGroup: textureMesh.vertexGroupTexture,
+ tNormal: textureMesh.normalTexture,
// aGroup is used as a vertex index here and the group id is retirieved from tPositionGroup
- aGroup: ValueCell.create(fillSerial(new Float32Array(isosurface.vertexCount.ref.value))),
+ aGroup: ValueCell.create(fillSerial(new Float32Array(textureMesh.vertexCount.ref.value))),
boundingSphere: ValueCell.create(transformBoundingSphere),
- invariantBoundingSphere: isosurface.boundingSphere,
+ invariantBoundingSphere: textureMesh.boundingSphere,
...color,
...marker,
@@ -121,13 +121,13 @@ export namespace Isosurface {
}
}
- function createValuesSimple(isosurface: Isosurface, props: Partial<PD.Values<Params>>, colorValue: Color, sizeValue: number, transform?: TransformData) {
+ function createValuesSimple(textureMesh: TextureMesh, props: Partial<PD.Values<Params>>, colorValue: Color, sizeValue: number, transform?: TransformData) {
const s = BaseGeometry.createSimple(colorValue, sizeValue, transform)
const p = { ...PD.getDefaultValues(Params), ...props }
- return createValues(isosurface, s.transform, s.locationIterator, s.theme, p)
+ return createValues(textureMesh, s.transform, s.locationIterator, s.theme, p)
}
- function updateValues(values: IsosurfaceValues, props: PD.Values<Params>) {
+ function updateValues(values: TextureMeshValues, props: PD.Values<Params>) {
if (Color.fromNormalizedArray(values.uHighlightColor.ref.value, 0) !== props.highlightColor) {
ValueCell.update(values.uHighlightColor, Color.toArrayNormalized(props.highlightColor, values.uHighlightColor.ref.value, 0))
}
@@ -142,8 +142,8 @@ export namespace Isosurface {
ValueCell.updateIfChanged(values.dFlipSided, props.flipSided)
}
- function updateBoundingSphere(values: IsosurfaceValues, isosurface: Isosurface) {
- const invariantBoundingSphere = isosurface.boundingSphere.ref.value
+ function updateBoundingSphere(values: TextureMeshValues, textureMesh: TextureMesh) {
+ const invariantBoundingSphere = textureMesh.boundingSphere.ref.value
const boundingSphere = calculateTransformBoundingSphere(invariantBoundingSphere, values.aTransform.ref.value, values.instanceCount.ref.value)
if (!Sphere3D.equals(boundingSphere, values.boundingSphere.ref.value)) {
ValueCell.update(values.boundingSphere, boundingSphere)
diff --git a/src/mol-gl/render-object.ts b/src/mol-gl/render-object.ts
index 43959218c714d639613820de9ed17e1a1c1bc219..ec7536ff335d4b2405125dd1088a109cc7d889ca 100644
--- a/src/mol-gl/render-object.ts
+++ b/src/mol-gl/render-object.ts
@@ -14,7 +14,7 @@ import { PointsValues, PointsRenderable } from './renderable/points';
import { LinesValues, LinesRenderable } from './renderable/lines';
import { SpheresValues, SpheresRenderable } from './renderable/spheres';
import { TextValues, TextRenderable } from './renderable/text';
-import { IsosurfaceValues, IsosurfaceRenderable } from './renderable/isosurface';
+import { TextureMeshValues, TextureMeshRenderable } from './renderable/texture-mesh';
const getNextId = idFactory(0, 0x7FFFFFFF)
@@ -27,11 +27,11 @@ export interface SpheresRenderObject extends BaseRenderObject { type: 'spheres',
export interface TextRenderObject extends BaseRenderObject { type: 'text', values: TextValues }
export interface LinesRenderObject extends BaseRenderObject { type: 'lines', values: LinesValues }
export interface DirectVolumeRenderObject extends BaseRenderObject { type: 'direct-volume', values: DirectVolumeValues }
-export interface IsosurfaceRenderObject extends BaseRenderObject { type: 'isosurface', values: IsosurfaceValues }
+export interface TextureMeshRenderObject extends BaseRenderObject { type: 'texture-mesh', values: TextureMeshValues }
//
-export type GraphicsRenderObject = MeshRenderObject | PointsRenderObject | SpheresRenderObject | TextRenderObject | LinesRenderObject | DirectVolumeRenderObject | IsosurfaceRenderObject
+export type GraphicsRenderObject = MeshRenderObject | PointsRenderObject | SpheresRenderObject | TextRenderObject | LinesRenderObject | DirectVolumeRenderObject | TextureMeshRenderObject
export type RenderObjectKindType = {
'mesh': MeshRenderObject
@@ -40,7 +40,7 @@ export type RenderObjectKindType = {
'text': TextRenderObject
'lines': LinesRenderObject
'direct-volume': DirectVolumeRenderObject
- 'isosurface': IsosurfaceRenderObject
+ 'texture-mesh': TextureMeshRenderObject
}
export type RenderObjectValuesType = {
'mesh': MeshValues
@@ -49,7 +49,7 @@ export type RenderObjectValuesType = {
'text': TextValues
'lines': LinesValues
'direct-volume': DirectVolumeValues
- 'isosurface': IsosurfaceValues
+ 'texture-mesh': TextureMeshValues
}
export type RenderObjectType = keyof RenderObjectKindType
@@ -67,6 +67,6 @@ export function createRenderable(ctx: WebGLContext, o: GraphicsRenderObject): Re
case 'text': return TextRenderable(ctx, o.id, o.values, o.state, o.materialId)
case 'lines': return LinesRenderable(ctx, o.id, o.values, o.state, o.materialId)
case 'direct-volume': return DirectVolumeRenderable(ctx, o.id, o.values, o.state, o.materialId)
- case 'isosurface': return IsosurfaceRenderable(ctx, o.id, o.values, o.state, o.materialId)
+ case 'texture-mesh': return TextureMeshRenderable(ctx, o.id, o.values, o.state, o.materialId)
}
}
\ No newline at end of file
diff --git a/src/mol-gl/renderable/isosurface.ts b/src/mol-gl/renderable/texture-mesh.ts
similarity index 80%
rename from src/mol-gl/renderable/isosurface.ts
rename to src/mol-gl/renderable/texture-mesh.ts
index 7ae65dd30e05782beaa2d49414411ad590233915..75f6f08b1a66bea15c48cce11e5b24532c1c992d 100644
--- a/src/mol-gl/renderable/isosurface.ts
+++ b/src/mol-gl/renderable/texture-mesh.ts
@@ -11,7 +11,7 @@ import { GlobalUniformSchema, BaseSchema, DefineSpec, Values, InternalSchema, In
import { MeshShaderCode } from '../shader-code';
import { ValueCell } from 'mol-util';
-export const IsosurfaceSchema = {
+export const TextureMeshSchema = {
...BaseSchema,
uGeoTexDim: UniformSpec('v2'),
@@ -24,11 +24,11 @@ export const IsosurfaceSchema = {
dFlipSided: DefineSpec('boolean'),
dGeoTexture: DefineSpec('boolean'),
}
-export type IsosurfaceSchema = typeof IsosurfaceSchema
-export type IsosurfaceValues = Values<IsosurfaceSchema>
+export type TextureMeshSchema = typeof TextureMeshSchema
+export type TextureMeshValues = Values<TextureMeshSchema>
-export function IsosurfaceRenderable(ctx: WebGLContext, id: number, values: IsosurfaceValues, state: RenderableState, materialId: number): Renderable<IsosurfaceValues> {
- const schema = { ...GlobalUniformSchema, ...InternalSchema, ...IsosurfaceSchema }
+export function TextureMeshRenderable(ctx: WebGLContext, id: number, values: TextureMeshValues, state: RenderableState, materialId: number): Renderable<TextureMeshValues> {
+ const schema = { ...GlobalUniformSchema, ...InternalSchema, ...TextureMeshSchema }
const internalValues: InternalValues = {
uObjectId: ValueCell.create(id),
uPickable: ValueCell.create(state.pickable ? 1 : 0)
diff --git a/src/tests/browser/marching-cubes.ts b/src/tests/browser/marching-cubes.ts
index a40c0ab8052765a470874b0cc55e67c8fd5b7925..b0b5cb07cda0b3a6af199c64948a382e03c99e0c 100644
--- a/src/tests/browser/marching-cubes.ts
+++ b/src/tests/browser/marching-cubes.ts
@@ -16,7 +16,7 @@ import { Vec3 } from 'mol-math/linear-algebra';
import { computeMarchingCubesMesh } from 'mol-geo/util/marching-cubes/algorithm';
import { Mesh } from 'mol-geo/geometry/mesh/mesh';
import { ColorNames } from 'mol-util/color/tables';
-import { Isosurface } from 'mol-geo/geometry/isosurface/isosurface';
+import { TextureMesh } from 'mol-geo/geometry/texture-mesh/texture-mesh';
import { calcActiveVoxels } from 'mol-gl/compute/marching-cubes/active-voxels';
import { createHistogramPyramid } from 'mol-gl/compute/histogram-pyramid/reduction';
import { createIsosurfaceBuffers } from 'mol-gl/compute/marching-cubes/isosurface';
@@ -110,13 +110,13 @@ async function init() {
const mcBoundingSphere = Sphere3D.zero()
Sphere3D.addVec3(mcBoundingSphere, mcBoundingSphere, densityTextureData.gridDimension)
console.log('mcBoundingSphere', mcBoundingSphere, densityTextureData.gridDimension)
- const mcIsosurface = Isosurface.create(gv.vertexCount, 1, gv.vertexGroupTexture, gv.normalTexture, mcBoundingSphere)
+ const mcIsosurface = TextureMesh.create(gv.vertexCount, 1, gv.vertexGroupTexture, gv.normalTexture, mcBoundingSphere)
const mcIsoSurfaceProps = { doubleSided: true, flatShaded: false, alpha: 1.0 }
- const mcIsoSurfaceValues = Isosurface.Utils.createValuesSimple(mcIsosurface, mcIsoSurfaceProps, Color(0x112299), 1)
+ const mcIsoSurfaceValues = TextureMesh.Utils.createValuesSimple(mcIsosurface, mcIsoSurfaceProps, Color(0x112299), 1)
// console.log('mcIsoSurfaceValues', mcIsoSurfaceValues)
- const mcIsoSurfaceState = Isosurface.Utils.createRenderableState(mcIsoSurfaceProps)
- const mcIsoSurfaceRenderObject = createRenderObject('isosurface', mcIsoSurfaceValues, mcIsoSurfaceState, -1)
- const mcIsoSurfaceRepr = Representation.fromRenderObject('isosurface', mcIsoSurfaceRenderObject)
+ const mcIsoSurfaceState = TextureMesh.Utils.createRenderableState(mcIsoSurfaceProps)
+ const mcIsoSurfaceRenderObject = createRenderObject('texture-mesh', mcIsoSurfaceValues, mcIsoSurfaceState, -1)
+ const mcIsoSurfaceRepr = Representation.fromRenderObject('texture-mesh', mcIsoSurfaceRenderObject)
canvas3d.add(mcIsoSurfaceRepr)
canvas3d.resetCamera()