BabylonJS文件格式---基于WebGL的H5 3D游戏引擎

最新推荐文章于 2024-04-13 12:19:57 发布
最新推荐文章于 2024-04-13 12:19:57 发布
阅读量8.4k 收藏 7
点赞数 3
分类专栏： webgl H53D BabylonJS 文章标签： webgl 游戏引擎 h53d
webgl 同时被 3 个专栏收录
12 篇文章 1 订阅
订阅专栏
H53D
12 篇文章 0 订阅
订阅专栏
BabylonJS
12 篇文章 2 订阅
订阅专栏

Babylon.js 使用JSON文件格式来描述场景.

你可以在这儿找到完整的加载器代码:
https://github.com/BabylonJS/Babylon.js/blob/master/src/Loading/Plugins/babylon.babylonFileLoader.js

基础类型

.babylon 文件使用下面的约定来定义基础类型:

  • Vector3: 一个含有3个浮点数([x, y, z])的数组. 例子: [1.1, 2.2, 3.3]
  • Vector4: 一个含有4个浮点数([x, y, z, w])的数组. 例子: [1.1, 2.2, 3.3, 4.4]
  • Color3: 一个含有3个浮点数 ([r, g, b])且每个数的值大小在0和1间的数组. 例子: [0.2, 0.3, 0.5]
  • Matrix: 行优先(先按行存储)的含有16个浮点数的数组
  • Boolean: 真或假

全局结构体

.babylon文件里的全局结构体是下面这样的:

{
    "autoClear": boolean,
    "clearColor": color3,
    "ambientColor": color3,
    "gravity": vector3 (通常是[0,-9,0]),
    "cameras": 相机数组 (见下面),
    "activeCamera_": string,
    "lights": 光源数组(见下面),
    "materials": 材质数组 (见下面),
    "geometries": {...} (见下面),
    "meshes": 网格数组 (见下面),
    "multiMaterials": 多材质数组(见下面),
    "shadowGenerators":  阴影生成器数组 (见下面),
    "skeletons": 骨架数组 (见下面),
    "particleSystems": 例子系统弄个数组 (见下面),
    "lensFlareSystems": 镜头光晕数组 (见下面),
    "actions": 动作数组 (见下面),
    "sounds": 音效数组 (见下面),
    "workerCollisions": boolean,
    "collisionsEnabled": boolean,
    "physicsEnabled": boolean,
    "physicsGravity": vector3 (默认是[0,-9.81,0]),
    "physicsEngine": string ("oimo" 或 "cannon", 引擎默认为(oimo),
    "animations": 动画数组 (见下面，可以省略),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean (可以省略),
    "autoAnimateSpeed": number (可以省略)
}

相机

一个相机通过如下JSON格式定义:

{
    "name": string,
    "id": string,
    "type": string,
    "tags": string,
    "parentId": string,
    "lockedTargetId": string,
    "position": vector3,
    "target": vector3,
    "alpha": float, // 仅仅支持ArcRotateCamera 和 AnaglyphArcRotateCamera
    "beta": float, // 仅仅支持 ArcRotateCamera 和 AnaglyphArcRotateCamera
    "radius": float, // 仅仅支持 ArcRotateCamera, FollowCamera 和 AnaglyphArcRotateCamera
    "eye_space": float, // 仅仅支持 AnaglyphFreeCamera 和 AnaglyphArcRotateCamera
    "heightOffset": float, // 仅仅支持 FollowCamera
    "rotationOffset": float, // 仅仅支持 FollowCamera
    "cameraRigMode": int (可以忽略),
    "fov": float (弧度单位),
    "minZ": float,
    "maxZ": float,
    "speed": float,
    "inertia": float (在0和1间),
    "checkCollisions": boolean,
    "applyGravity": boolean,
    "ellipsoid": vector3,
    "animations": Animations数组 (见下面，可以忽略),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean (可以忽略),
    "autoAnimateSpeed": number (可以忽略),
    "inputmgr" : 相机的输入映射(可以忽略, 见下面)
}

相机的输入映射

这是个对象，它字面上用输入类型作为键，同时用输入设定作为存储值对象。每个输入类型都有其自身的属性.

光源

光源通过如下的JSON格式定义:

{
    "name": string,
    "id": string,
    "tags": string,
    "type": int (0表示点光，1表示方向光, 2表示聚光，3表示球面光),
    "position": vector3,
    "direction": vector3,
    "angle": float (用于点光源),
    "exponent": float (用于点光源),
    "groundColor": color3 (用于球面光光源),
    "intensity": float,
    "range": float,
    "diffuse": color3,
    "specular": color3,
    "excludedMeshesIds": array of string,
    "includedOnlyMeshesIds": array of string,
    "animations": array of Animations (见下面，可以忽略),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean (可以忽略),
    "autoAnimateSpeed": number (可以忽略)
}

材质

一个材质通过如下JSON格式定义:

{
    "name": string,
    "id": string,
    "tags": string,
    "disableDepthWrite": boolean (可以忽略),
    "ambient": color3,
    "diffuse": color3,
    "specular": color3,
    "specularPower": float,
    "emissive": color3,
    "alpha": float,
    "backFaceCulling": boolean,
    "wireframe": boolean,
    "diffuseTexture": Texture (见下面),
    "ambientTexture": Texture (见下面),
    "opacityTexture": Texture (见下面,
    "reflectionTexture": Texture (见下面),
    "refractionTexture": Texture (见下面),
    "indexOfRefraction": float,
    "emissiveTexture": Texture (见下面),
    "specularTexture": Texture (见下面),
    "bumpTexture": Texture (见下面),
    "lightmapTexture": Texture (见下面),
    "useLightmapAsShadowmap": boolean,
    "checkReadyOnlyOnce": boolean
    "useReflectionFresnelFromSpecular": boolean (可以忽略),
    "useEmissiveAsIllumination": boolean (可以忽略),
    "diffuseFresnelParameters": 菲涅耳参数 (见下面),
    "opacityFresnelParameters": 菲涅耳参数 (见下面),
    "reflectionFresnelParameters": 菲涅耳参数 (见下面),
    "refractionFresnelParameters": 菲涅耳参数 (见下面),
    "emissiveFresnelParameters": 菲涅耳参数 (见下面)
}

菲涅耳参数

菲涅耳参数通过如下的JSON格式定义:

{
    "isEnabled": boolean,
    "leftColor": color3,
    "rightColor": color3,
    "bias": float,
    "power": float
}

纹理

纹理通过如下的JSON个格式定义:

{
    "name": string (文件名),
    "level": float (在0和1间),
    "hasAlpha": boolean,
    "getAlphaFromRGB": boolean,
    "coordinatesMode": int (0 = 显式, 1 = 球, 2 = 平面, 3 = 立方, 4 = 投影, 5 = 天空盒),
    "uOffset": float,
    "vOffset": float,
    "uScale": float,
    "vScale": float,
    "uAng": float,
    "vAng": float,
    "wAng": float,
    "wrapU": boolean,
    "wrapV": boolean,
    "coordinatesIndex": int,
    "animations": array of Animations (见下面，可以忽略),
    "base64String": string (可以忽略)
}

多纹理

多纹理通过如下JSON格式定义:

{
    "name": string,
    "id": string,
    "tags": string,
    "materials": string数组 (都是子纹理的ID)
}

几何体

几何体的结构如下:

{
    "boxes": array of Boxes (见下面),
    "spheres": array of Spheres (见下面),
    "cylinders": array of Cylinders (见下面),
    "toruses": array of Toruses (见下面),
    "grounds": array of Grounds (见下面),
    "planes": array of Planes (见下面),
    "torusKnots": array of TorusKnots (见下面),
    "vertexData": array of VertexData (见下面)
}

盒子

盒子通过如下的JSON格式定义:

{
    "id": string,
    "size": float,
    "canBeRegenerated": bool,
    "tags": string
}

球体

球体通过如下的JSON格式定义:

{
    "id": string,
    "segments": float,
    "diameter": float,
    "canBeRegenerated": bool,
    "tags": string
}

圆柱体

圆柱体通过如下的JSON格式定义:

{
    "id": string,
    "height": float,
    "diameterTop": float,
    "diameterBottom": float,
    "tessellation": float,
    "subdivisions": integer,
    "canBeRegenerated": bool,
    "tags": string
}

环形体

环型体通过如下的JSON定义:

{
    "id": string,
    "diameter": float,
    "thickness": float,
    "tessellation": float,
    "canBeRegenerated": bool,
    "tags": string
}

地面

地面通过如下的JSON格式定义:

{
    "id": string,
    "width": float,
    "height": float,
    "subdivisions": float,
    "canBeRegenerated": bool,
    "tags": string
}

平面

平面通过如下的JSON格式定义:

{
    "id": string,
    "size": float,
    "canBeRegenerated": bool,
    "tags": string
}

环形节

环形节通过如下的JSON格式定义:

{
    "id": string,
    "radius": float,
    "tube": float,
    "radialSegments": float,
    "tubularSegments": float,
    "p": float,
    "q": float,
    "canBeRegenerated": bool,
    "tags": string
}

顶点数据

顶点数据通过如下的JSON格式定义:

{
    "id": string,
    "updatable": bool,
    "positions": array of floats (每顶点3个数值),
    "normals": array of floats (每顶点3个数值),
    "uvs": array of floats (每顶点2个数值),
    "uv2s": array of floats (每顶点2个数值) 第2个纹理坐标 (可以忽略),
    "uv3s": array of floats (每顶点2个数值) 第3个纹理坐标 (可以忽略),
    "uv4s": array of floats (每顶点2个数值) 第4个纹理坐标 (可以忽略),
    "uv5s": array of floats (每顶点2个数值) 第5个纹理坐标 (可以忽略),
    "uv6s": array of floats (每顶点2个数值) 第6个纹理坐标 (可以忽略),
    "colors": array of floats (每顶点3个数值)每个顶点的颜色 (可以忽略),
    "matricesIndices": array of ints (每顶点4个数值) 骨骼数据在矩阵数组里的索引 (可以忽略),
    "matricesWeights": array of floats (每顶点4个数值) 骨骼数据在矩阵数组里的权重  (可以忽略),
    "indices": array of ints (每面点3个数值),
    "tags": string
}

实例

实例通过如下的JSON格式定义:

{
    "name": string,
    "tags": string,
    "position": vector3,
    "rotation": vector3 (可以忽略),
    "rotationQuaternion": vector4 (可以忽略),
    "scaling": vector3
}

网格

网格通过如下的JSON格式定义:

{
    "name": string,
    "id": string,
    "tags": string,
    "parentId": string,
    "materialId": string,
    "geometryId": string (可以忽略),
    "position": vector3,
    "rotation": vector3 (可以忽略),
    "rotationQuaternion": vector4 (可以忽略),
    "scaling": vector3,
    "pivotMatrix": matrix,
    "freezeWorldMatrix": boolean (可以忽略),
    "infiniteDistance": boolean,
    "showBoundingBox": boolean,
    "showSubMeshesBoundingBox": boolean,
    "isVisible": boolean,
    "isEnabled": boolean,
    "pickable": boolean,
    "applyFog": boolean,
    "alphaIndex": int,
    "checkCollisions": boolean,
    "billboardMode": int (0 = None, 1 = X, 2 = Y, 4 = Z, 7 = All),
    "receiveShadows": boolean,
    "physicsImpostor": int (0 = None, 1 = Box, 2 = Sphere),
    "physicsMass": float,
    "physicsFriction": float,
    "physicsRestitution": float,
    "positions": array of floats (每顶点3个数值),
    "normals": array of floats (每顶点3个数值),
    "uvs": array of floats (每顶点2个数值),
    "uvs2": array of floats (每顶点2个数值)  第2个纹理坐标(可以忽略),
    "uv3s": array of floats (每顶点2个数值)  第3个纹理坐标 (可以忽略),
    "uv4s": array of floats (每顶点2个数值)  第5个纹理坐标 (可以忽略),
    "uv5s": array of floats (每顶点2个数值)  第6个纹理坐标 (可以忽略),
    "uv6s": array of floats (每顶点2个数值)  第7个纹理坐标 (可以忽略),
    "colors": array of floats (每顶点4个数值) 每个顶点的颜色 (可以忽略),
    "hasVertexAlpha": 指明颜色是否包含透明信息的值(可以忽略),
    "matricesIndices": array of ints (每顶点4个数值)  骨骼数据在矩阵数组里的索引  (可以忽略),
    "matricesWeights": array of floats (每顶点4个数值)  骨骼数据在矩阵数组里的权重 (可以忽略),
    "indices": array of ints (每面3个数值,
    "subMeshes": array of SubMeshes (见下面),
    "animations": array of Animations (见下面, 可以忽略),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean,
    "autoAnimateSpeed": number (可以忽略)
    "instances": array of Instances (见下面, 可以忽略),
    "actions": array of actions (见下面)
}

请注意，父网格的描述必须在其子节点出现之前。

子网格

子网格通过如下的JSON格式定义:

{
    "materialIndex": int,
    "verticesStart": int,
    "verticesCount": int,
    "indexStart": int,
    "indexCount": int
}

动画

动画通过如下的JSON格式定义:

{
    "dataType": int (0 = 浮点, 1 = 3元量, 2 = 4元量, 3 = 矩阵),
    "framePerSecond": int,
    "loopBehavior": int (0 = 相对, 1 = 周期, 2 = 常量),
    "name": string,
    "property": string,
    "keys": array of AnimationKeys (见下面),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean
}

动画关键帧

动画关键帧通过如下的JSON格式定义:

{
    "frame": int,
    "values": array of float (取决于播放的值)
}

阴影生成器

阴影生成器通过如下的JSON格式定义:

{
    "useBlurVarianceShadowMap": boolean,
    "useVarianceShadowMap": boolean,
    "usePoissonSampling": boolean,
    "mapSize": int (在64和2048之间, 必须是2的幂),
    "bias": float,
    "forceBackFacesOnly": float,
    "lightId": string,
    "renderList": array of string (网格的ID)
}

骨架

骨架通过如下的JSON格式定义:

{
    "name": string,
    "id": string,
    "bones": array of Bones (见下面)
    "needInitialSkinMatrix": boolean
}

骨骼

骨骼通过如下的JSON格式定义:

{
    "parentBoneIndex": int,
    "name": string,
    "matrix": matrix,
    "animations": array of Animations (必须是个矩阵类型)
}

粒子系统

粒子系统通过如下的JSON格式定义:

{
     "emitterId": string,
     "gravity": vector3,
     "direction1": vector3,
     "direction2": vector3,
     "minEmitBox": vector3,
     "maxEmitBox": vector3,
     "color1": color3,
     "color2": color3,
     "colorDead": color3,
     "deadAlpha": float,
     "emitRate": float,
     "updateSpeed": float,
     "targetStopFrame": int,
     "minEmitPower": int,
     "maxEmitPower": float,
     "minLifeTime": float,
     "maxLifeTime": float,
     "minSize": float,
     "maxSize": float,
     "minAngularSpeed": float,
     "maxAngularSpeed": float,
     "textureName": string,
     "blendMode": int,
     "capacity": int,
     "textureMask": color4,
     "linkToEmitter": bool,
    "animations": Animations数组 (见下面，可以省略),
    "autoAnimate": boolean,
    "autoAnimateFrom": int,
    "autoAnimateTo": int,
    "autoAnimateLoop": boolean (可以省略),
    "autoAnimateSpeed": number (可以忽略)
}

镜头光晕系统

镜头光晕系统通过如下的JSON格式定义:

{
     "emitterId": string,
     "borderLimit": int,
     "flares": array of LensFlares (见下面)
}

镜头光晕

镜头光晕通过如下的JSON格式定义:

{
     "position": float,
     "size": float,
     "color": color3,
     "textureName": string
}

音效

音效通过如下的JSON格式定义:

{
     "name": string, (要加载的文件名)
     "volume": float, (如果忽略则为1)
     "autoplay": bool, (可忽略)
     "loop": bool, (可忽略)
     "soundTrackId": int, (可忽略)
     "spatialSound": bool, (启用3维音效，可忽略)
     "position": vector3, (如果忽略则为0,0,0)
     "refDistance": float, (可忽略, 默认为1)
     "rolloffFactor": float, (可忽略, 默认为1)
     "maxDistance": float, (可忽略, 默认为100)
     "distanceModel": string, (可忽略, 默认为线性的，其它值: 倒数或指数)
     "panningModel": string, (可忽略, 默认为HRTF, 其它值: 等幂)
     "isDirectional": bool, (启用方向椎体)
     "coneInnerAngle": float, (可忽略,用来设置有向音效)
     "coneOuterAngle": float, (可忽略,用来设置有向音效)
     "coneOuterGain": float, (可忽略,用来设置有向音效)
     "connectedMeshId": string, (网格附着对象的ID)
     "localDirectionToMesh": vector3 (可忽略,默认1,0,0)
}

动作

动作通过如下的JSON格式定义. 动作可以包含多个子的动作.

{
    "type": number, (动作类型. 0 = 触发式, 1 = 动作, 2 = 流控制)
    "name": string, (触发式或流程的动作名)
    "detached": boolean, (节点是否挂载上. 如果detached === true意味着不会被计算)
    "properties": array of properties, (见下面)
    "children": array of Actions,
    "combine": array of Actions (用于组合动画. 例如 name = "CombineAction". 可以为null)
}

属性通过如下JSON格式定义. 属性值总是字符串

{
    "name": string, (属性名)
    "value": string, (属性值. 例如: name = "target" 和 value = "Plane001")
    "targetType": string (BabylonJS动作创建器内部使用的, 指明在哪找到"propertyPath"属性的)
}

例子

这儿是个简单的.babylon文件的例子:

{
    "autoClear": true,
    "clearColor": [0, 0, 0],
    "ambientColor": [0, 0, 0],
    "gravity": [0, -9.81, 0],
    "cameras": [{
        "name": "Camera",
        "id": "Camera",
        "position": [7.4811, 5.3437, -6.5076],
        "target": [-0.3174, 0.8953, 0.3125],
        "fov": 0.8576,
        "minZ": 0.1,
        "maxZ": 100,
        "speed": 1,
        "inertia": 0.9,
        "checkCollisions": false,
        "applyGravity": false,
        "ellipsoid": [0.2, 0.9, 0.2]
    }],
    "activeCamera": "Camera",
    "lights": [{
        "name": "Sun",
        "id": "Sun",
        "type": 1,
        "position": [0.926, 7.3608, 14.1829],
        "direction": [-0.347, -0.4916, -0.7987],
        "intensity": 1,
        "diffuse": [1, 1, 1],
        "specular": [1, 1, 1]
    }],
    "materials": [{
        "name": "Material",
        "id": "Material",
        "ambient": [0.8, 0.8, 0.8],
        "diffuse": [0.64, 0.64, 0.64],
        "specular": [0.5, 0.5, 0.5],
        "specularPower": 50,
        "emissive": [0, 0, 0],
        "alpha": 1,
        "backFaceCulling": true,
        "diffuseTexture": {
            "name": "Metal1.png",
            "level": 1,
            "hasAlpha": 1,
            "coordinatesMode": 0,
            "uOffset": 0,
            "vOffset": 0,
            "uScale": 1,
            "vScale": 1,
            "uAng": 0,
            "vAng": 0,
            "wAng": 0,
            "wrapU": true,
            "wrapV": true,
            "coordinatesIndex": 0
        }
    },
    {
        "name": "Material.001",
        "id": "Material.001",
        "ambient": [0.8, 0.8, 0.8],
        "diffuse": [0.64, 0.64, 0.64],
        "specular": [0.5, 0.5, 0.5],
        "specularPower": 50,
        "emissive": [0, 0, 0],
        "alpha": 1,
        "backFaceCulling": true,
        "diffuseTexture": {
            "name": "concrete5.png",
            "level": 1,
            "hasAlpha": 1,
            "coordinatesMode": 0,
            "uOffset": 0,
            "vOffset": 0,
            "uScale": 5,
            "vScale": 5,
            "uAng": 0,
            "vAng": 0,
            "wAng": 0,
            "wrapU": true,
            "wrapV": true,
            "coordinatesIndex": 0
        }
    }],
    "geometries": {
        "boxes": [{
            "id": "BoxPrimitive",
            "size": 2,
            "canBeRegenerated": true,
            "tags": "Box Primitive Cube CanBeRegenerated"
        }],
        "vertexData": [{
            "id": "CubeGeometry",
            "updatable": false,
            "positions": [ 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, 1],
            "normals": [0.5773, -0.5773, 0.5773, 0.5773, -0.5773, -0.5773, -0.5773, -0.5773, 0.5773, 0.5773, 0.5773, 0.5773, -0.5773, 0.5773, 0.5773, 0.5773, 0.5773, -0.5773, 0.5773, 0.5773, 0.5773, 0.5773, -0.5773, -0.5773, 0.5773, -0.5773, -0.5773, 0.5773, 0.5773, -0.5773, -0.5773, -0.5773, -0.5773, -0.5773, -0.5773, -0.5773, -0.5773, 0.5773, -0.5773, -0.5773, -0.5773, 0.5773, 0.5773, 0.5773, 0.5773, 0.5773, -0.5773, 0.5773, -0.5773, 0.5773, 0.5773, -0.5773, -0.5773, -0.5773, -0.5773, 0.5773, -0.5773, 0.5773, 0.5773, 0.5773, 0.5773, 0.5773, -0.5773, 0.5773, -0.5773, -0.5773, 0.5773, 0.5773, -0.5773, -0.5773, 0.5773, -0.5773, -0.5773, 0.5773, 0.5773, -0.5773, -0.5773, 0.5773, 0.5773, -0.5773, 0.5773, -0.5773, -0.5773, 0.5773, -0.5773, 0.5773, 0.5773],
            "uvs": [0.5, 0.5, 0.5, 0, 0, 0.5, 0.5, 1, 0, 1, 0.5, 0.5, 0.5, 1, 0, 0.5, 0.5, 0.5, 0.5, 1, 0, 0.5, 0.5, 0.5, 0.5, 1, 1, 0.5, 0.5, 0.5, 0.5, 0, 0, 0.5, 0, 0, 0, 0.5, 0.5, 1, 0, 1, 0, 0.5, 0.5, 1, 0, 1, 1, 1, 1, 0.5, 0.5, 0, 0, 0, 0, 0.5],
            "indices": [0, 1, 2, 3, 4, 5, 0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1, 17, 2, 4, 18, 5, 19, 20, 21, 22, 23, 10, 12, 24, 25, 26, 27, 28]
        }]
    },
    "meshes": [{
        "name": "Plane",
        "id": "Plane",
        "materialId": "Material.001",
        "position": [0.0172, -2.9787, -0.5184],
        "rotation": [0, 0, 0],
        "scaling": [87.1479, 0.8635, 87.1479],
        "isVisible": true,
        "isEnabled": true,
        "checkCollisions": false,
        "billboardMode": 0,
        "receiveShadows": true,
        "positions": [-1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, 1],
        "normals": [0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0],
        "uvs": [0.0001, 0.0001, 0.9999, 0.0001, 0.0001, 0.9999, 0.9999, 0.9999],
        "indices": [0, 1, 2, 1, 3, 2],
        "subMeshes": [{
            "materialIndex": 0,
            "verticesStart": 0,
            "verticesCount": 4,
            "indexStart": 0,
            "indexCount": 6
        }]
    },
    {
        "name": "Cube",
        "id": "Cube",
        "materialId": "Material",
        "geometryId": "CubeGeometry",
        "position": [0, 0, 0],
        "rotation": [0, 0, 0],
        "scaling": [1, 1, 1],
        "isVisible": true,
        "isEnabled": true,
        "checkCollisions": false,
        "billboardMode": 0,
        "receiveShadows": false,
        "subMeshes": [{
            "materialIndex": 0,
            "verticesStart": 0,
            "verticesCount": 29,
            "indexStart": 0,
            "indexCount": 36
        }],
        "animations": [{
            "dataType": 1,
            "framePerSecond": 30,
            "loopBehavior": 1,
            "name": "position animation",
            "property": "position",
            "keys": [{
                "frame": 0,
                "values": [0,0,0.0291]
            },
            {
                "frame": 1,
                "values": [0,0,0.0291]
            },
            {
                "frame": 30,
                "values": [0,0,10]
            },
            {
                "frame": 60,
                "values": [0,0,9.975]
            },
            {
                "frame": 90,
                "values": [0,0,0]
            },
            {
                "frame": 250,
                "values": [0,0,0]
            }]
        },
        {
            "dataType": 1,
            "framePerSecond": 30,
            "loopBehavior": 1,
            "name": "rotation animation",
            "property": "rotation",
            "keys": [{
                "frame": 0,
                "values": [-0.016, 0, 0]
            },
            {
                "frame": 30,
                "values": [-0.016, 0, 0]
            },
            {
                "frame": 60,
                "values": [-6.2832, 0, 0]
            },
            {
                "frame": 250,
                "values": [-6.2832, 0, 0]
            }]
        }],
        "autoAnimate": true,
        "autoAnimateFrom": 0,
        "autoAnimateTo": 250,
        "autoAnimateLoop": true
    },
    {
        "name": "Cube2",
        "id": "Cube2",
        "materialId": "Material",
        "geometryId": "CubeGeometry",
        "position": [10, 0, 0],
        "rotation": [0, 0, 0],
        "scaling": [1, 1, 1],
        "isVisible": true,
        "isEnabled": true,
        "checkCollisions": false,
        "billboardMode": 0,
        "receiveShadows": false,
        "subMeshes": [{
            "materialIndex": 0,
            "verticesStart": 0,
            "verticesCount": 29,
            "indexStart": 0,
            "indexCount": 36
        }]
    },
    {
        "name": "Cube3",
        "id": "Cube3",
        "materialId": "Material",
        "geometryId": "BoxPrimitive",
        "position": [-10, 0, 0],
        "rotation": [0, 0, 0],
        "scaling": [1, 1, 1],
        "isVisible": true,
        "isEnabled": true,
        "checkCollisions": false,
        "billboardMode": 0,
        "receiveShadows": false,
        "subMeshes": [{
            "materialIndex": 0,
            "verticesStart": 0,
            "verticesCount": 29,
            "indexStart": 0,
            "indexCount": 36
        }]
    }],
    "multiMaterials": [],
    "shadowGenerators": [{
        "useVarianceShadowMap": true,
        "mapSize": 1024,
        "lightId": "Sun",
        "renderList": ["Cube", "Cube2", "Cube3"]
    }],
    "skeletons": [],
    "sounds": [{
        "name": "violons11.wav",
        "volume": 1,
        "autoplay": true,
        "loop": true,
        "soundTrackId": 1
        "spatialSound": true,
        "position": [0, 0, 0]
        "refDistance": 1.0,
        "rolloffFactor": 1.0,
        "maxDistance": 100,
        "distanceModel": "linear",
        "panningModel": "equalpower",
        "isDirectional": false,
        "coneInnerAngle": 90,
        "coneOuterAngle": 180,
        "coneOuterGain": 0,
        "connectedMeshId": 0,
        "localDirectionToMesh": [1, 0, 0]
   }]
}

原文地址:http://doc.babylonjs.com/generals/File_Format_Map_(.babylon)#grounds
github上译文:https://github.com/h53d/babylonjs-doc-cn/blob/master/target/generals/General/File_Format_Map_(.babylon).md

aceway
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Blender导出babylon格式插件
06-01
Blender转Babylon格式插件。 安装步骤见https://doc.babylonjs.com/
unrust：unrust-基于纯生锈（基于webgl 2.0的本机）的游戏引擎
02-05
unrust：unrust-基于纯生锈（基于webgl 2.0的本机）的游戏引擎
babylonjs中文文档（最佳入门）
谷子的博客
02-25 508
babylonjs中文文档
html5 webgl stl,新闻|Babylon.js|Babylon.js教程|Babylon.js开发|Babylon.js制作|webgl|three.js|html53D可视化开发...
weixin_35663151的博客
06-28 1946
4.0.0主要更新添加了对ammo.js的支持， 作为物理插件(复合对象，电机，关节)(TrevorDev)Added 在ammo.js物理插件中增加了对 3D软体，2D布和1D绳索的软体的支持(JohnK)添加了 AmmoJSPlugin场景文件加载器(MackeyK24)添加了对WebXR支持(TrevorDev)添加 customAnimationFrameRequester以允许会话挂钩到...
babylonjs 分部加载模型_17 Babylonjs入门进阶 使用场景加载器加载glTF，OBJ，STL模型...
weixin_42355411的博客
01-12 1166
Babylon.js内置的模型格式是.babylon，Babylon.js可以不需要其它额外的插件即可加载。注意：由于你导入的模型可以具有rotationQuaternion的设置，因此再设置rotate可能出现无法预测的问题，警告基本用法要加载指定的类型的文件，Babylon.js首先需要引入相应文件的插件。目前支持的文件格式类型：如果想要快速添加对所有的文件格式的支持，可以将以下脚本引入到页面...
Babylon.js把图片拖动到画布中
weixin_40252368的博客
08-28 185
把图片拖动到画布中，生成对应的三维模型
Babylon.js 第32章 绘制边界框
m0_73334402的博客
09-11 596
以上两者的不同点是：第一个的边界会随着spher的位置而转移，第二个不会。如果你想获得定位对象的世界边界呢？这实际上很容易做到。我们将对 sphereMin、sphereMax、groundMin、groundMax 值进行一些小的修改。
babylon导入_从字符串或json动态载入babylonjs文件
weixin_39616855的博客
12-19 809
转载该文章请发邮件到：[email protected]说明情况，删除该段文字视为侵权！Babylonjs/threejs技术群(QQ群)：154398355有些时候，我们可能并不想从外部导入的babylon导出文件，或者说不想导入完整的babylon文件，这个babylon的文件可能是动态生成的，比如不同的动画组或者材质组等等，同时载入完整的babylon文件可能会占用更高的资源。总之baby...
Babylon.js 第15章 GUI
m0_73334402的博客
09-07 1286
在复杂的网格上处理指针移动事件可能代价高昂，因此您可以使用第四个参数关闭支持指针移动事件。二、observables属性。一、创建GUI的两种模式。
babylon导入_77Three.js导入BABYLON格式的模型
weixin_42469578的博客
01-26 2477
简介babylon是一个三维javascript游戏库，它以自己的内部格式存储模型。实现案例首先，引入script加载器然后，实例化加载器对象，然后加载模型，将获取到的模型进行处理，放到scene当中即可。var loader = new three.babylonloader();loader.load("/lib/assets/models/babylon/skull.babylon", fu...
Babylon.js 第24章 混合模式
m0_73334402的博客
09-08 306
请注意，混合操作实际上是对像素值的 R、G 和 B 分量分别进行的简单数学运算，每个分量都介于 0 和 1 之间。因此，具有绿色网格（R=0，G=1， B=0) 设置用 ALPHA_SUBTRACT 绘制在黄色 (R=1, G=1, B=0) 上将发出红色值 (R=1, G=0, B=0)。在 alpha 混合网格的情况下，新像素不会简单地覆盖现有像素：它们根据网格的透明度进行。您可以通过使不透明网格变得非常透明来强制不透明网格进行 alpha 混合，材料的属性来完成的，将其设置为上面列出的常数之一。
vts-browser-js:JavaScript WebGL 3D地图渲染引擎
04-29
VTS浏览器JS是功能强大JavaScript 3D地图渲染引擎，占地面积很小（约163 kB的gzip压缩JS代码）。 它几乎提供了您想要的基于Web的3D映射的所有功能。 VTS浏览器JS是独立可用部分：这是用于3D地理空间应用程序开发的...
feng3d：基于WebGL的3D游戏引擎
01-28
feng3d feng3d是使用TypeScript进行编写基于WebGL的3D游戏引擎，致力于打造一个优秀的3d游戏引擎以及易用且可以快速开发项目的配套编辑器。特性提供优质的typescript编辑器支持脚本，你能够在这里实现所有你想做的...
Dice:grrd的骰子-HTML5 PWA WebGL 3D骰子和yahtzee游戏
05-04
grrd的骰子grrd的Dice是HTML5 3D Dice Roller... 3D WebGL图形是通过three.js实现的。 grrd's Dice是免费的，没有广告，没有应用内购买。 版权所有（c）2015 Gerard Tyedmers， 根据MPL许可获得许可单击此处播放： :
Unity-WebGL-Utilities：一些有用的Unity WebGL游戏实用程序
02-06
Unity-WebGL-实用程序 基于Unity团队的博客文章和WebGL Essentials资产包并从中获得启发的Unity WebGL游戏的一些有用实用程序。 正在安装 获取并将unitypackage导入到您的项目中。 WebGLMemoryStats 这是一种简单的...
体渲染原理及WebGL实现【Volume Rendering】
新缸中之脑
08-12 2013
体渲染（Volume Rendering）是NeRF神经场辐射AI模型的基础，与传统渲染使用三角形来显示 3D 图形不同，体渲染使用其他方法，例如体积光线投射 (Volume Ray Casting)。本文介绍体渲染的原理并提供Three.js实现代码，源代码可以从下载。推荐：用快速搭建可编程3D场景。
GAMS104 现代游戏引擎 2
zaizai1007的博客
04-13 1154
5，渲染中光和材质的数学魔法，6，7，游戏中地形大气和云的渲染，游戏中的渲染管线，后处理等
node-v16.12.0-darwin-x64.tar.xz
最新发布
04-23
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
试用Dev Containers的示例项目-Go
04-23
计算机技术是指评价计算机系统的各种知识和技能的总称。它涵盖了计算机硬件、软件、网络和信息安全等方面。计算机技术的发展使我们能够进行高效的数据处理、信息存储和传输。现代计算机技术包括操作系统、数据库管理、编程语言、算法设计等。同时，人工智能、云计算和大数据等新兴技术也在不断推动计算机技术的进步。计算机技术的应用广泛，涵盖了各个领域，如商业、医疗、教育和娱乐等。随着计算机技术的不断革新，我们可以更加高效地实现预期自动化、标准化
基于 webgl 的 h5 游戏引擎
07-14
WebGL是一种基于OpenGL ES的3D图形渲染技术，可以在Web浏览器中渲染3D图形。下面是一些基于WebGL的H5游戏引擎： 1. Three.js：Three.js是一个流行的基于WebGL的3D图形库，可以用于创建3D场景、动画和游戏。它提供了易于使用的API和丰富的示例，可以轻松地创建各种类型的3D游戏。 2. Babylon.js：Babylon.js是另一个基于WebGL的3D图形库，可以用于创建游戏和交互式应用程序。它提供了强大的物理引擎、高级材质和灯光系统，可以创建逼真的3D场景和动画。 3. PlayCanvas：PlayCanvas是一个基于WebGL的游戏引擎，可以用于创建高性能的2D和3D游戏。它提供了易于使用的可视化编辑器和JavaScript API，可以创建各种类型的游戏，包括跑酷、射击、策略等。 4. Phaser：Phaser是一个基于WebGL的2D游戏引擎，可以用于创建各种类型的2D游戏，如平台游戏、街机游戏、射击游戏等。它提供了易于使用的API和丰富的示例，可以轻松地创建各种类型的2D游戏。 5. PixiJS：PixiJS是一个基于WebGL的2D游戏引擎，可以用于创建高性能的2D游戏和应用程序。它提供了易于使用的API和丰富的示例，可以轻松地创建各种类型的2D游戏。 这些基于WebGL的H5游戏引擎都拥有强大的功能和易于使用的API，可以帮助开发者快速创建高质量的游戏和应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值