玩法 / PhysicsService
PhysicsService Class
碰撞组
Table of contents
Accessors
touchesUseCollisionGroups(): boolean |
---|
确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件 |
Methods
addCollisionGroup(name : string ): void |
---|
添加新碰撞组 |
boxOverlap(boxPos : Vector , boxExtent : Vector , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): GameObject [] |
返回一个与给定盒体重叠的对象数组 |
boxTraceMulti(start : Vector , end : Vector , halfSize : Vector , orientation : Rotation , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult [] |
沿着给定的路线扫描一个盒体,并返回遇到的所有命中,包括第一次拦截命中。 |
boxTraceSingle(start : Vector , end : Vector , halfSize : Vector , orientation : Rotation , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult |
沿着给定的线扫过一个盒体,并返回遇到的第一个阻挡命中。 |
capsuleOverlap(capsulePos : Vector , radius : number , halfHeight : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): GameObject [] |
返回一个与给定胶囊体重叠的对象数组 |
capsuleTraceMulti(start : Vector , end : Vector , radius : number , halfHeight : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult [] |
沿着给定的路线扫描一个胶囊,并返回遇到的所有命中,包括第一次拦截命中。 |
capsuleTraceSingle(start : Vector , end : Vector , radius : number , halfHeight : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult |
沿着给定的线扫过一个胶囊体,并返回遇到的第一个阻挡命中。 |
deleteCollisionGroup(name : string ): void |
删除已有碰撞组 |
getAvailableCollisionGroupsCount(): number |
获取当前可剩余使用碰撞组数量 |
getCollisionBetweenGroups(group1 : string , group2 : string ): boolean |
获取两碰撞组之间的碰撞关系(是否可发生碰撞) |
getValidCollisionGroups(): string [] |
获取当前已添加的碰撞组名列表 |
isCollisionGroupValid(name : string ): boolean |
检测碰撞组是否有效(已添加过) |
lineTraceMulti(start : Vector , end : Vector , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult [] |
沿着给定的行执行碰撞跟踪,并返回遇到的所有命中,直到并包括第一次阻塞命中。 |
lineTraceSingle(start : Vector , end : Vector , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult |
沿着给定的线进行碰撞追踪,并返回遇到的第一个阻挡命中。 |
renameCollisionGroup(previousName : string , newName : string ): void |
重命名碰撞组 |
setCollisionBetweenGroups(group1 : string , group2 : string , collidable : boolean ): void |
设置俩碰撞组之间的碰撞关系(是否可发生碰撞) |
sphereOverlap(spherePos : Vector , sphereRadius : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): GameObject [] |
返回一个与给定球体重叠的对象数组 |
sphereTraceMulti(start : Vector , end : Vector , radius : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult [] |
沿着给定的直线扫过一个球体,并返回所有命中,包括第一次拦截命中。 |
sphereTraceSingle(start : Vector , end : Vector , radius : number , collisionParams : CollisionQueryParams , renderParams : RenderQueryParams ): HitResult |
沿着给定的线扫过一个球体,并返回遇到的第一个阻挡命中。 |
Accessors
touchesUseCollisionGroups
• | • | ||||
---|---|---|---|---|---|
确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件 Returns
| 确定不同组中设置为不碰撞的模型是否在忽略碰撞的同时忽略touch事件 Parameters
|
在场景中创建一个名为TouchesUseCollisionGroups的脚本,并拖入场景中,并复制以下代码进入脚本。 依次按下1、2之后,会发现服务器会小球会调用onTouch函数并输出对应LOG。
ts
@Component
export default class TouchesUseCollisionGroups extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.touchesUseCollisionGroups = true;
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建正常碰撞的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
this.serverCreateBall(new Vector(300, 0, 0), "GroupA", false);
})
// 创建模拟物理的球体B并设置碰撞组为GroupB
InputUtil.onKeyDown(Keys.Two, ()=>{
this.serverCreateBall(new Vector(300, 0, 100), "GroupB", true);
})
}
@mw.RemoteFunction(mw.Server)
serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
{
GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
let ball = obj as mw.Model;
ball.worldTransform.position = pos;
if (bPhysicsSimulate)
{
ball.physicsEnabled = true;
ball.massEnabled = true;
ball.mass = 50;
}
ball.collisionGroup = Group;
ball.onTouch.add((obj : GameObject) => {
console.log(`${obj.gameObjectId} - Touch - ${ball.gameObjectId}`);
}
);
})
}
}
@Component
export default class TouchesUseCollisionGroups extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.touchesUseCollisionGroups = true;
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建正常碰撞的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
this.serverCreateBall(new Vector(300, 0, 0), "GroupA", false);
})
// 创建模拟物理的球体B并设置碰撞组为GroupB
InputUtil.onKeyDown(Keys.Two, ()=>{
this.serverCreateBall(new Vector(300, 0, 100), "GroupB", true);
})
}
@mw.RemoteFunction(mw.Server)
serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
{
GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
let ball = obj as mw.Model;
ball.worldTransform.position = pos;
if (bPhysicsSimulate)
{
ball.physicsEnabled = true;
ball.massEnabled = true;
ball.mass = 50;
}
ball.collisionGroup = Group;
ball.onTouch.add((obj : GameObject) => {
console.log(`${obj.gameObjectId} - Touch - ${ball.gameObjectId}`);
}
);
})
}
}
Methods
addCollisionGroup
• Static
addCollisionGroup(name
): void
添加新碰撞组
Parameters
name string | 碰撞组名 range: 不限制 |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.addCollisionGroup("GroupC");
console.log(PhysicsService.getValidCollisionGroups());
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.addCollisionGroup("GroupC");
console.log(PhysicsService.getValidCollisionGroups());
})
}
}
boxOverlap
• Static
boxOverlap(boxPos
, boxExtent
, collisionParams
, renderParams
): GameObject
[]
返回一个与给定盒体重叠的对象数组
Parameters
boxPos Vector | 检测位置 |
---|---|
boxExtent Vector | 盒体大小 |
collisionParams CollisionQueryParams | 碰撞查询渲染参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
GameObject [] | GameObject数组 |
---|
ts
const result = PhysicsService.boxOverlap(new mw.Vector(0,0,0), new Vector(30, 30, 30), {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.boxOverlap(new mw.Vector(0,0,0), new Vector(30, 30, 30), {}, {});
for (const item of result) {
// item: 检测结果。
}
boxTraceMulti
• Static
boxTraceMulti(start
, end
, halfSize
, orientation
, collisionParams
, renderParams
): HitResult
[]
沿着给定的路线扫描一个盒体,并返回遇到的所有命中,包括第一次拦截命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
halfSize Vector | 盒形大小 |
orientation Rotation | 旋转大小 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult [] | HitResult数组 |
---|
ts
const result = PhysicsService.boxTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.boxTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
for (const item of result) {
// item: 检测结果。
}
boxTraceSingle
• Static
boxTraceSingle(start
, end
, halfSize
, orientation
, collisionParams
, renderParams
): HitResult
沿着给定的线扫过一个盒体,并返回遇到的第一个阻挡命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
halfSize Vector | 盒形大小 |
orientation Rotation | 旋转大小 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult | HitResult |
---|
ts
const result = PhysicsService.boxTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
const result = PhysicsService.boxTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), new Vector(30, 30, 30), new Rotation(45, 45, 45), {}, {});
capsuleOverlap
• Static
capsuleOverlap(capsulePos
, radius
, halfHeight
, collisionParams
, renderParams
): GameObject
[]
返回一个与给定胶囊体重叠的对象数组
Parameters
capsulePos Vector | 检测位置 |
---|---|
radius number | 胶囊体半径 |
halfHeight number | 胶囊体半高 |
collisionParams CollisionQueryParams | 碰撞查询渲染参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
GameObject [] | GameObject数组 |
---|
ts
const result = PhysicsService.capsuleOverlap(new mw.Vector(0,0,0), 30, 80, {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.capsuleOverlap(new mw.Vector(0,0,0), 30, 80, {}, {});
for (const item of result) {
// item: 检测结果。
}
capsuleTraceMulti
• Static
capsuleTraceMulti(start
, end
, radius
, halfHeight
, collisionParams
, renderParams
): HitResult
[]
沿着给定的路线扫描一个胶囊,并返回遇到的所有命中,包括第一次拦截命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
radius number | 胶囊体半径 |
halfHeight number | 胶囊体半高 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult [] | HitResult数组 |
---|
ts
const result = PhysicsService.capsuleTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.capsuleTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
for (const item of result) {
// item: 检测结果。
}
capsuleTraceSingle
• Static
capsuleTraceSingle(start
, end
, radius
, halfHeight
, collisionParams
, renderParams
): HitResult
沿着给定的线扫过一个胶囊体,并返回遇到的第一个阻挡命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
radius number | 胶囊体半径 |
halfHeight number | 胶囊体半高 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult | HitResult |
---|
ts
const result = PhysicsService.capsuleTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
const result = PhysicsService.capsuleTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, 80, {}, {});
deleteCollisionGroup
• Static
deleteCollisionGroup(name
): void
删除已有碰撞组
Parameters
name string | 碰撞组名 range: 不限制 |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.deleteCollisionGroup("GroupA");
console.log(PhysicsService.getValidCollisionGroups());
})
}
protected onUpdate(dt: number): void {
}
// 脚本被销毁时最后一帧执行完调用此函数
protected onDestroy(): void {
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.deleteCollisionGroup("GroupA");
console.log(PhysicsService.getValidCollisionGroups());
})
}
protected onUpdate(dt: number): void {
}
// 脚本被销毁时最后一帧执行完调用此函数
protected onDestroy(): void {
}
}
getAvailableCollisionGroupsCount
• Static
getAvailableCollisionGroupsCount(): number
获取当前可剩余使用碰撞组数量
Returns
number | 剩余可用碰撞组数量 |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getAvailableCollisionGroupsCount());
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getAvailableCollisionGroupsCount());
})
}
}
getCollisionBetweenGroups
• Static
getCollisionBetweenGroups(group1
, group2
): boolean
获取两碰撞组之间的碰撞关系(是否可发生碰撞)
Parameters
group1 string | 碰撞组名 1 range: 不限制 |
---|---|
group2 string | 碰撞组名 2 range: 不限制 |
Returns
boolean | 碰撞关系(是否可发生碰撞) |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getCollisionBetweenGroups("GroupA", "GroupB"));
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getCollisionBetweenGroups("GroupA", "GroupB"));
})
}
}
getValidCollisionGroups
• Static
getValidCollisionGroups(): string
[]
获取当前已添加的碰撞组名列表
Returns
string [] | 当前已添加的碰撞组名列表 |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getValidCollisionGroups());
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.getValidCollisionGroups());
})
}
}
isCollisionGroupValid
• Static
isCollisionGroupValid(name
): boolean
检测碰撞组是否有效(已添加过)
Parameters
name string | 碰撞组名 range: 不限制 |
---|
Returns
boolean | 碰撞组是否有效 |
---|
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.isCollisionGroupValid("GroupC"));
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
console.log(PhysicsService.isCollisionGroupValid("GroupC"));
})
}
}
lineTraceMulti
• Static
lineTraceMulti(start
, end
, collisionParams
, renderParams
): HitResult
[]
沿着给定的行执行碰撞跟踪,并返回遇到的所有命中,直到并包括第一次阻塞命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult [] | HitResult数组 |
---|
ts
const result = PhysicsService.lineTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.lineTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
for (const item of result) {
// item: 检测结果。
}
lineTraceSingle
• Static
lineTraceSingle(start
, end
, collisionParams
, renderParams
): HitResult
沿着给定的线进行碰撞追踪,并返回遇到的第一个阻挡命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult | HitResult |
---|
ts
const result = PhysicsService.lineTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
const result = PhysicsService.lineTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), {}, {});
renameCollisionGroup
• Static
renameCollisionGroup(previousName
, newName
): void
重命名碰撞组
Parameters
previousName string | 碰撞组名 range: 不限制 |
---|---|
newName string | 新碰撞组名 range: 不限制 |
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.renameCollisionGroup("GroupA","GroupC");
console.log(PhysicsService.getValidCollisionGroups());
})
}
protected onUpdate(dt: number): void {
}
// 脚本被销毁时最后一帧执行完调用此函数
protected onDestroy(): void {
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
PhysicsService.renameCollisionGroup("GroupA","GroupC");
console.log(PhysicsService.getValidCollisionGroups());
})
}
protected onUpdate(dt: number): void {
}
// 脚本被销毁时最后一帧执行完调用此函数
protected onDestroy(): void {
}
}
setCollisionBetweenGroups
• Static
setCollisionBetweenGroups(group1
, group2
, collidable
): void
设置俩碰撞组之间的碰撞关系(是否可发生碰撞)
Parameters
group1 string | 碰撞组名1 range: 不限制 |
---|---|
group2 string | 碰撞组名2 range: 不限制 |
collidable boolean | 是否可碰撞 |
ts
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
this.serverCreateBall(new Vector(300, 0, 0), "GroupA", true);
})
// 创建正常碰撞的球体B并设置碰撞组为GroupB
InputUtil.onKeyDown(Keys.Two, ()=>{
this.serverCreateBall(new Vector(600, 0, 0), "GroupB", false);
})
}
@mw.RemoteFunction(mw.Server)
serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
{
GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
let ball = obj as mw.Model;
ball.worldTransform.position = pos;
if (bPhysicsSimulate)
{
ball.physicsEnabled = true;
ball.massEnabled = true;
ball.mass = 50;
}
ball.collisionGroup = Group;
})
}
}
@Component
export default class CollisionGroup extends Script {
// 当脚本被实例后,会在第一帧更新前调用此函数
protected onStart(): void {
PhysicsService.addCollisionGroup("GroupA");
PhysicsService.addCollisionGroup("GroupB");
PhysicsService.setCollisionBetweenGroups("GroupA", "GroupB", false);
// 创建模拟物理的球体A并设置碰撞组为GroupA
InputUtil.onKeyDown(Keys.One, ()=>{
this.serverCreateBall(new Vector(300, 0, 0), "GroupA", true);
})
// 创建正常碰撞的球体B并设置碰撞组为GroupB
InputUtil.onKeyDown(Keys.Two, ()=>{
this.serverCreateBall(new Vector(600, 0, 0), "GroupB", false);
})
}
@mw.RemoteFunction(mw.Server)
serverCreateBall(pos:Vector, Group:string, bPhysicsSimulate:boolean)
{
GameObject.asyncSpawn("197388", {replicates:true}).then((obj)=>{
let ball = obj as mw.Model;
ball.worldTransform.position = pos;
if (bPhysicsSimulate)
{
ball.physicsEnabled = true;
ball.massEnabled = true;
ball.mass = 50;
}
ball.collisionGroup = Group;
})
}
}
sphereOverlap
• Static
sphereOverlap(spherePos
, sphereRadius
, collisionParams
, renderParams
): GameObject
[]
返回一个与给定球体重叠的对象数组
Parameters
spherePos Vector | 检测位置 |
---|---|
sphereRadius number | 球半径 |
collisionParams CollisionQueryParams | 碰撞查询渲染参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
GameObject [] | GameObject数组 |
---|
ts
const result = PhysicsService.sphereOverlap(new mw.Vector(0,0,0), 30, {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.sphereOverlap(new mw.Vector(0,0,0), 30, {}, {});
for (const item of result) {
// item: 检测结果。
}
sphereTraceMulti
• Static
sphereTraceMulti(start
, end
, radius
, collisionParams
, renderParams
): HitResult
[]
沿着给定的直线扫过一个球体,并返回所有命中,包括第一次拦截命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
radius number | 球形半径 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult [] | HitResult数组 |
---|
ts
const result = PhysicsService.sphereTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
for (const item of result) {
// item: 检测结果。
}
const result = PhysicsService.sphereTraceMulti(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
for (const item of result) {
// item: 检测结果。
}
sphereTraceSingle
• Static
sphereTraceSingle(start
, end
, radius
, collisionParams
, renderParams
): HitResult
沿着给定的线扫过一个球体,并返回遇到的第一个阻挡命中。
Parameters
start Vector | 起始点 |
---|---|
end Vector | 终止点 |
radius number | 球形半径 |
collisionParams CollisionQueryParams | 空间查询碰撞参数 |
renderParams RenderQueryParams | 空间查询渲染参数 |
Returns
HitResult | HitResult |
---|
ts
const result = PhysicsService.sphereTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});
const result = PhysicsService.sphereTraceSingle(new mw.Vector(0,0,0), new mw.Vector(1000,0,0), 30, {}, {});