-
Notifications
You must be signed in to change notification settings - Fork 3.4k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
When I picked up a 3Dtile, an error occurred #11990
Comments
Hi @HKEFU , please supplement the version information, and then provide relevant sandcastle or tileset to help you better track the issue. It seems that the issue lies in this piece of code: cesium/packages/engine/Source/Scene/Model/PickingPipelineStage.js Lines 158 to 161 in db62d07
|
The cesium version is 1.116.0。 |
Hi @HKEFU. As @syzdev suggested, would you be able to include a Sandcastle example that replicates the issue? That would help us give us more context to determine the issue. Thanks! |
Hi @ggetz. This zip file is the sample code, and the video shows this error message.Thanks! video url: https://github.com/CesiumGS/cesium/assets/169979994/e3f4f705-2d14-41ce-9865-a533a4fe191f |
Hi @HKEFU, I identified a few errors with the linked tileset using the 3D Tiles Validator tool. I'd suggest running the tool and fixing any errors. |
What happened?
[Cesium WebGL] Vertex shader compile log: ERROR: 0:72: 'selectedFeature' : undeclared identifier
ERROR: 0:72: 'id' : field selection requires structure, vector, or interface block on left hand side
ERROR: 0:72: '<' : wrong operand types - no operation '<' exists that takes a left-hand operand of type 'const highp float' and a right operand of type 'highp int' (or there is no acceptable conversion)
ERROR: 0:72: 'model_pickTexture' : undeclared identifier
ERROR: 0:72: 'selectedFeature' : undeclared identifier
ERROR: 0:72: 'st' : field selection requires structure, vector, or interface block on left hand side
ERROR: 0:72: 'texture' : no matching overloaded function found
ERROR: 0:72: '?:' : mismatching ternary operator operand types 'const mediump float and 'const 4-component vector of float'
Reproduction steps
...
Sandcastle example
No response
Environment
[Cesium WebGL] Vertex shader source:
#version 300 es
#define HAS_ATMOSPHERE
#define COMPUTE_POSITION_WC_ATMOSPHERE
#define HAS_NORMALS
#define HAS_TEXCOORD_0
#define HAS_FEATURE_ID_0
#define HAS_SELECTED_FEATURE_ID
#define SELECTED_FEATURE_ID featureId_0
#define HAS_SELECTED_FEATURE_ID_ATTRIBUTE
#define USE_CPU_STYLING
#define LOG_DEPTH
#define OES_texture_float_linear
#define OES_texture_float
#line 0
const float czm_infinity = 5906376272000.0;
struct czm_ray
{
vec3 origin;
vec3 direction;
};
struct czm_raySegment
{
float start;
float stop;
};
const czm_raySegment czm_emptyRaySegment = czm_raySegment(-czm_infinity, -czm_infinity);
const czm_raySegment czm_fullRaySegment = czm_raySegment(0.0, czm_infinity);
uniform vec3 czm_atmosphereRayleighCoefficient;
uniform vec3 czm_atmosphereMieCoefficient;
uniform float czm_atmosphereMieScaleHeight;
uniform float czm_atmosphereRayleighScaleHeight;
float czm_approximateTanh(float x) {
float x2 = x * x;
return max(-1.0, min(1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));
}
czm_raySegment czm_raySphereIntersectionInterval(czm_ray ray, vec3 center, float radius)
{
vec3 o = ray.origin;
vec3 d = ray.direction;
}
uniform vec2 czm_currentFrustum;
uniform mat4 czm_inverseProjection;
void czm_computeScattering(
czm_ray primaryRay,
float primaryRayLength,
vec3 lightDirection,
float atmosphereInnerRadius,
out vec3 rayleighColor,
out vec3 mieColor,
out float opacity
) {
const float ATMOSPHERE_THICKNESS = 111e3;
const int PRIMARY_STEPS_MAX = 16;
const int LIGHT_STEPS_MAX = 4;
}
uniform vec3 czm_viewerPositionWC;
uniform vec3 czm_sunDirectionWC;
uniform vec3 czm_lightDirectionWC;
#ifdef LOG_DEPTH
out float v_depthFromNearPlusOne;
#ifdef SHADOW_MAP
out vec3 v_logPositionEC;
#endif
#endif
vec4 czm_updatePositionDepth(vec4 coords) {
#if defined(LOG_DEPTH)
#ifdef SHADOW_MAP
vec3 logPositionEC = (czm_inverseProjection * coords).xyz;
v_logPositionEC = logPositionEC;
#endif
#endif
}
void czm_vertexLogDepth()
{
#ifdef LOG_DEPTH
v_depthFromNearPlusOne = (gl_Position.w - czm_currentFrustum.x) + 1.0;
gl_Position = czm_updatePositionDepth(gl_Position);
#endif
}
void czm_vertexLogDepth(vec4 clipCoords)
{
#ifdef LOG_DEPTH
v_depthFromNearPlusOne = (clipCoords.w - czm_currentFrustum.x) + 1.0;
czm_updatePositionDepth(clipCoords);
#endif
}
uniform mat3 czm_normal;
uniform mat4 czm_modelView;
uniform mat3 czm_normal3D;
uniform mat4 czm_modelView3D;
struct czm_modelVertexOutput {
vec3 positionMC;
float pointSize;
};
const float czm_passTranslucent = 8.0;
uniform float czm_pass;
uniform mat4 czm_model;
uniform mat4 czm_projection;
void czm_computeGroundAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity) {
vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;
vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);
czm_ray primaryRay = czm_ray(czm_viewerPositionWC, cameraToPositionWCDirection);
}
uniform float czm_atmosphereDynamicLighting;
vec3 czm_getDynamicAtmosphereLightDirection(vec3 positionWC, float lightEnum) {
const float NONE = 0.0;
const float SCENE_LIGHT = 1.0;
const float SUNLIGHT = 2.0;
}
float czm_round(float value) {
return floor(value + 0.5);
}
vec2 czm_round(vec2 value) {
return floor(value + 0.5);
}
vec3 czm_round(vec3 value) {
return floor(value + 0.5);
}
vec4 czm_round(vec4 value) {
return floor(value + 0.5);
}
#line 0
in vec3 a_positionMC;
in vec3 a_normalMC;
in vec2 a_texCoord_0;
in float a_featureId_0;
uniform int model_featuresLength;
uniform sampler2D model_batchTexture;
uniform vec4 model_textureStep;
uniform bool model_commandTranslucent;
out vec3 v_atmosphereRayleighColor;
out vec3 v_atmosphereMieColor;
out float v_atmosphereOpacity;
out vec3 v_positionWC;
out vec3 v_positionEC;
out vec3 v_positionMC;
out vec3 v_normalEC;
out vec2 v_texCoord_0;
out float v_featureId_0;
struct ProcessedAttributes
{
vec3 positionMC;
vec3 normalMC;
vec2 texCoord_0;
float featureId_0;
};
struct SelectedFeature
{
int id;
vec2 st;
vec4 color;
};
struct FeatureIds
{
int featureId_0;
};
struct Metadata
{
float _empty;
};
struct MetadataClass
{
float _empty;
};
struct MetadataStatistics
{
float _empty;
};
void initializeAttributes(out ProcessedAttributes attributes)
{
attributes.positionMC = a_positionMC;
attributes.normalMC = a_normalMC;
attributes.texCoord_0 = a_texCoord_0;
attributes.featureId_0 = a_featureId_0;
}
void setDynamicVaryings(inout ProcessedAttributes attributes)
{
v_texCoord_0 = attributes.texCoord_0;
v_featureId_0 = attributes.featureId_0;
}
void initializeFeatureIds(out FeatureIds featureIds, ProcessedAttributes attributes)
{
featureIds.featureId_0 = int(czm_round(attributes.featureId_0));
}
void initializeFeatureIdAliases(inout FeatureIds featureIds)
{
}
void setFeatureIdVaryings()
{
}
void initializeMetadata(out Metadata metadata, out MetadataClass metadataClass, out MetadataStatistics metadataStatistics, ProcessedAttributes attributes)
{
}
void setMetadataVaryings()
{
}
void atmosphereStage(ProcessedAttributes attributes) {
vec3 lightDirection = czm_getDynamicAtmosphereLightDirection(v_positionWC, czm_atmosphereDynamicLighting);
}
vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal)
{
vec4 computedPosition;
}
void featureIdStage(out FeatureIds featureIds, ProcessedAttributes attributes)
{
initializeFeatureIds(featureIds, attributes);
initializeFeatureIdAliases(featureIds);
setFeatureIdVaryings();
}
void metadataStage(
out Metadata metadata,
out MetadataClass metadataClass,
out MetadataStatistics metadataStatistics,
ProcessedAttributes attributes
)
{
initializeMetadata(metadata, metadataClass, metadataStatistics, attributes);
setMetadataVaryings();
}
vec2 computeSt(float featureId)
{
float stepX = model_textureStep.x;
float centerX = model_textureStep.y;
}
void selectedFeatureIdStage(out SelectedFeature feature, FeatureIds featureIds)
{
int featureId = featureIds.SELECTED_FEATURE_ID;
}
void filterByPassType(inout vec3 positionMC, vec4 featureColor)
{
bool styleTranslucent = (featureColor.a != 1.0);
}
void cpuStylingStage(inout vec3 positionMC, inout SelectedFeature feature)
{
float show = ceil(feature.color.a);
positionMC *= show;
}
czm_modelVertexOutput defaultVertexOutput(vec3 positionMC) {
czm_modelVertexOutput vsOutput;
vsOutput.positionMC = positionMC;
vsOutput.pointSize = 1.0;
return vsOutput;
}
void czm_log_depth_main()
{
}
#line 0
void czm_non_renderPass_OutlineEffectPass_main()
{
czm_log_depth_main();
czm_vertexLogDepth();
}
#line 0
vec3 packNormalToRGB(const in vec3 normal) {
return normalize(normal) * 0.5 + 0.5;
}
vec3 unpackRGBToNormal(const in vec3 rgb) {
return 2.0 * rgb.xyz - 1.0;
}
const float PackUpscale = 256. / 255.;
const float UnpackDownscale = 255. / 256.;
const vec3 PackFactors = vec3(256. * 256. * 256., 256. * 256., 256.);
const vec4 UnpackFactors = UnpackDownscale / vec4(PackFactors, 1.);
const float ShiftRight8 = 1. / 256.;
vec4 packDepthToRGBA(const in float v) {
vec4 r = vec4(fract(v * PackFactors), v);
r.yzw -= r.xyz * ShiftRight8;
return r * PackUpscale;
}
float unpackRGBAToDepth(const in vec4 v) {
return dot(v, UnpackFactors);
}
vec4 pack2HalfToRGBA(vec2 v) {
vec4 r = vec4(v.x, fract(v.x * 255.0), v.y, fract(v.y * 255.0));
return vec4(r.x - r.y / 255.0, r.y, r.z - r.w / 255.0, r.w);
}
vec2 unpackRGBATo2Half(vec4 v) {
return vec2(v.x + (v.y / 255.0), v.z + (v.w / 255.0));
}
float viewZToOrthographicDepth(const in float viewZ, const in float near, const in float far) {
return (viewZ + near) / (near - far);
}
float orthographicDepthToViewZ(const in float linearClipZ, const in float near, const in float far) {
return linearClipZ * (near - far) - near;
}
float viewZToPerspectiveDepth(const in float viewZ, const in float near, const in float far) {
return ((near + viewZ) * far) / ((far - near) * viewZ);
}
float perspectiveDepthToViewZ(const in float invClipZ, const in float near, const in float far) {
return (near * far) / ((far - near) * invClipZ - far);
}
uniform sampler2D czm_selectedIdTexture;
uniform float czm_selectedIdTextureStep;
uniform float czm_selectedIdTextureWidth;
bool czm_selected(vec4 id) {
bool selected = false;
for (int i = 0; i < 1024000; i++)
{
vec4 selectedId = texture(czm_selectedIdTexture, vec2((float(i) + 0.5) * czm_selectedIdTextureStep, 0.5));
if(all(equal(id, selectedId)))
{
return true;
}
if(float(i) > czm_selectedIdTextureWidth) break;
}
return false;
}
out float me_isSelected;
bool czm_selected() {
return czm_selected(((selectedFeature.id < int(model_featuresLength)) ? texture(model_pickTexture, selectedFeature.st) : vec4(0.0)));
}
{
czm_non_renderPass_OutlineEffectPass_main();
me_isSelected = czm_selected() ? 1. : 0.;
czm_renderPass_OutlineEffectPass_main();
}
The text was updated successfully, but these errors were encountered: