592 lines
15 KiB
C++
592 lines
15 KiB
C++
#include <rw.h>
|
|
#include <skeleton.h>
|
|
|
|
#include "subrast.h"
|
|
|
|
rw::Camera *Camera;
|
|
rw::Camera *SubCameras[4];
|
|
|
|
void
|
|
CameraSetViewWindow(rw::Camera *camera, float width, float height, float vw)
|
|
{
|
|
rw::V2d viewWindow;
|
|
|
|
// TODO: aspect ratio when fullscreen
|
|
if(width > height){
|
|
viewWindow.x = vw;
|
|
viewWindow.y = vw / (width/height);
|
|
}else{
|
|
viewWindow.x = vw / (height/width);
|
|
viewWindow.y = vw;
|
|
}
|
|
|
|
camera->setViewWindow(&viewWindow);
|
|
}
|
|
|
|
void
|
|
UpdateSubRasters(rw::Camera *mainCamera, rw::int32 mainWidth, rw::int32 mainHeight)
|
|
{
|
|
rw::Rect rect[4];
|
|
float width, height, border;
|
|
|
|
border = mainHeight*0.05f;
|
|
|
|
width = (mainWidth - border*3.0f) / 2.0f;
|
|
height = (mainHeight - border*3.0f) / 2.0f;
|
|
|
|
// top left
|
|
rect[0].x = border;
|
|
rect[0].y = border;
|
|
rect[0].w = width;
|
|
rect[0].h = height;
|
|
|
|
// top right
|
|
rect[1].x = border*2 + width;
|
|
rect[1].y = border;
|
|
rect[1].w = width;
|
|
rect[1].h = height;
|
|
|
|
// bottom left
|
|
rect[2].x = border;
|
|
rect[2].y = border*2 + height;
|
|
rect[2].w = width;
|
|
rect[2].h = height;
|
|
|
|
// bottom left
|
|
rect[3].x = border*2 + width;
|
|
rect[3].y = border*2 + height;
|
|
rect[3].w = width;
|
|
rect[3].h = height;
|
|
|
|
CameraSetViewWindow(SubCameras[0], width, height, 0.5f);
|
|
for(int i = 1; i < 4; i++)
|
|
CameraSetViewWindow(SubCameras[i], width, height, 0.5f + 0.4f);
|
|
|
|
for(int i = 0; i < 4; i++){
|
|
SubCameras[i]->frameBuffer->subRaster(mainCamera->frameBuffer, &rect[i]);
|
|
SubCameras[i]->zBuffer->subRaster(mainCamera->zBuffer, &rect[i]);
|
|
}
|
|
}
|
|
|
|
void
|
|
PositionSubCameras(void)
|
|
{
|
|
rw::Frame *frame;
|
|
rw::V3d pos;
|
|
const float dist = 2.5f;
|
|
|
|
// perspective
|
|
pos.x = pos.y = 0.0f;
|
|
pos.z = -4.0f;
|
|
frame = SubCameras[0]->getFrame();
|
|
frame->translate(&pos, rw::COMBINEREPLACE);
|
|
|
|
// look along z
|
|
pos.x = pos.y = 0.0f;
|
|
pos.z = -dist;
|
|
frame = SubCameras[1]->getFrame();
|
|
frame->translate(&pos, rw::COMBINEREPLACE);
|
|
|
|
// look along x
|
|
pos.x = -dist;
|
|
pos.y = pos.z = 0.0f;
|
|
frame = SubCameras[2]->getFrame();
|
|
frame->rotate(&Yaxis, 90.0f, rw::COMBINEREPLACE);
|
|
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
|
|
// look along y
|
|
pos.x = pos.z = 0.0f;
|
|
pos.y = -dist;
|
|
frame = SubCameras[3]->getFrame();
|
|
frame->rotate(&Xaxis, -90.0f, rw::COMBINEREPLACE);
|
|
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
}
|
|
|
|
void
|
|
CreateCameras(rw::World *world)
|
|
{
|
|
Camera = sk::CameraCreate(sk::globals.width, sk::globals.height, 1);
|
|
assert(Camera);
|
|
|
|
for(int i = 0; i < 4; i++){
|
|
SubCameras[i] = sk::CameraCreate(0, 0, 1);
|
|
assert(SubCameras[i]);
|
|
|
|
SubCameras[i]->setNearPlane(0.1f);
|
|
SubCameras[i]->setFarPlane(30.0f);
|
|
|
|
world->addCamera(SubCameras[i]);
|
|
|
|
if(i > 0)
|
|
SubCameras[i]->setProjection(rw::Camera::PARALLEL);
|
|
}
|
|
|
|
PositionSubCameras();
|
|
}
|
|
|
|
void
|
|
DestroyCameras(rw::World *world)
|
|
{
|
|
}
|
|
|
|
/*
|
|
|
|
rw::Light *BaseAmbientLight;
|
|
bool BaseAmbientLightOn;
|
|
|
|
rw::Light *CurrentLight;
|
|
rw::Light *AmbientLight;
|
|
rw::Light *PointLight;
|
|
rw::Light *DirectLight;
|
|
rw::Light *SpotLight;
|
|
rw::Light *SpotSoftLight;
|
|
|
|
float LightRadius = 100.0f;
|
|
float LightConeAngle = 45.0f;
|
|
rw::RGBAf LightColor = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
|
|
rw::RGBA LightSolidColor = { 255, 255, 0, 255 };
|
|
bool LightOn = true;
|
|
bool LightDrawOn = true;
|
|
rw::V3d LightPos = {0.0f, 0.0f, 75.0f};
|
|
rw::int32 LightTypeIndex = 1;
|
|
|
|
rw::BBox RoomBBox;
|
|
|
|
rw::Light*
|
|
CreateBaseAmbientLight(void)
|
|
{
|
|
rw::Light *light = rw::Light::create(rw::Light::AMBIENT);
|
|
assert(light);
|
|
light->setColor(0.5f, 0.5f, 0.5f);
|
|
return light;
|
|
}
|
|
|
|
rw::Light*
|
|
CreateAmbientLight(void)
|
|
{
|
|
return rw::Light::create(rw::Light::AMBIENT);
|
|
}
|
|
|
|
rw::Light*
|
|
CreateDirectLight(void)
|
|
{
|
|
rw::Light *light = rw::Light::create(rw::Light::DIRECTIONAL);
|
|
assert(light);
|
|
rw::Frame *frame = rw::Frame::create();
|
|
assert(frame);
|
|
frame->rotate(&Xaxis, 45.0f, rw::COMBINEREPLACE);
|
|
rw::V3d pos = LightPos;
|
|
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
light->setFrame(frame);
|
|
return light;
|
|
}
|
|
|
|
rw::Light*
|
|
CreatePointLight(void)
|
|
{
|
|
rw::Light *light = rw::Light::create(rw::Light::POINT);
|
|
assert(light);
|
|
light->radius = LightRadius;
|
|
rw::Frame *frame = rw::Frame::create();
|
|
assert(frame);
|
|
rw::V3d pos = LightPos;
|
|
frame->translate(&pos, rw::COMBINEREPLACE);
|
|
light->setFrame(frame);
|
|
return light;
|
|
}
|
|
|
|
rw::Light*
|
|
CreateSpotLight(void)
|
|
{
|
|
rw::Light *light = rw::Light::create(rw::Light::SPOT);
|
|
assert(light);
|
|
light->radius = LightRadius;
|
|
light->setAngle(LightConeAngle/180.0f*M_PI);
|
|
rw::Frame *frame = rw::Frame::create();
|
|
assert(frame);
|
|
frame->rotate(&Xaxis, 45.0f, rw::COMBINEREPLACE);
|
|
rw::V3d pos = LightPos;
|
|
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
light->setFrame(frame);
|
|
return light;
|
|
}
|
|
|
|
rw::Light*
|
|
CreateSpotSoftLight(void)
|
|
{
|
|
rw::Light *light = rw::Light::create(rw::Light::SOFTSPOT);
|
|
assert(light);
|
|
light->radius = LightRadius;
|
|
light->setAngle(LightConeAngle/180.0f*M_PI);
|
|
rw::Frame *frame = rw::Frame::create();
|
|
assert(frame);
|
|
frame->rotate(&Xaxis, 45.0f, rw::COMBINEREPLACE);
|
|
rw::V3d pos = LightPos;
|
|
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
light->setFrame(frame);
|
|
return light;
|
|
}
|
|
|
|
void
|
|
DestroyLight(rw::Light **light)
|
|
{
|
|
if(*light == nil)
|
|
return;
|
|
rw::World *world = (*light)->world;
|
|
if(world)
|
|
world->removeLight(*light);
|
|
rw::Frame *frame = (*light)->getFrame();
|
|
if(frame){
|
|
(*light)->setFrame(nil);
|
|
frame->destroy();
|
|
}
|
|
|
|
(*light)->destroy();
|
|
*light = nil;
|
|
}
|
|
|
|
void
|
|
LightsDestroy(void)
|
|
{
|
|
DestroyLight(&SpotSoftLight);
|
|
DestroyLight(&SpotLight);
|
|
DestroyLight(&PointLight);
|
|
DestroyLight(&DirectLight);
|
|
DestroyLight(&AmbientLight);
|
|
DestroyLight(&BaseAmbientLight);
|
|
}
|
|
|
|
void
|
|
LightsUpdate(void)
|
|
{
|
|
static rw::int32 oldLightTypeIndex = -1;
|
|
|
|
// Switch to a different light
|
|
if((LightOn && oldLightTypeIndex != LightTypeIndex) || CurrentLight == nil){
|
|
oldLightTypeIndex = LightTypeIndex;
|
|
|
|
// remove first
|
|
if(CurrentLight)
|
|
CurrentLight->world->removeLight(CurrentLight);
|
|
|
|
switch(LightTypeIndex){
|
|
case 0: CurrentLight = AmbientLight; break;
|
|
case 1: CurrentLight = PointLight; break;
|
|
case 2: CurrentLight = DirectLight; break;
|
|
case 3: CurrentLight = SpotLight; break;
|
|
case 4: CurrentLight = SpotSoftLight; break;
|
|
}
|
|
World->addLight(CurrentLight);
|
|
}
|
|
|
|
if(CurrentLight){
|
|
CurrentLight->setColor(LightColor.red, LightColor.green, LightColor.blue);
|
|
CurrentLight->radius = LightRadius;
|
|
CurrentLight->setAngle(LightConeAngle / 180.0f * M_PI);
|
|
}
|
|
|
|
// Remove light from world if not used
|
|
if(!LightOn && CurrentLight){
|
|
CurrentLight->world->removeLight(CurrentLight);
|
|
CurrentLight = nil;
|
|
}
|
|
}
|
|
|
|
#define POINT_LIGHT_RADIUS_FACTOR 0.05f
|
|
|
|
void
|
|
DrawPointLight(void)
|
|
{
|
|
enum { NUMVERTS = 50 };
|
|
rw::RWDEVICE::Im3DVertex shape[NUMVERTS];
|
|
rw::int32 i;
|
|
rw::V3d point;
|
|
|
|
rw::V3d *pos = &CurrentLight->getFrame()->getLTM()->pos;
|
|
for(i = 0; i < NUMVERTS; i++){
|
|
point.x = pos->x +
|
|
cosf(i/(NUMVERTS/2.0f) * M_PI) * LightRadius * POINT_LIGHT_RADIUS_FACTOR;
|
|
point.y = pos->y +
|
|
sinf(i/(NUMVERTS/2.0f) * M_PI) * LightRadius * POINT_LIGHT_RADIUS_FACTOR;
|
|
point.z = pos->z;
|
|
|
|
shape[i].setColor(LightSolidColor.red, LightSolidColor.green,
|
|
LightSolidColor.blue, LightSolidColor.alpha);
|
|
shape[i].setX(point.x);
|
|
shape[i].setY(point.y);
|
|
shape[i].setZ(point.z);
|
|
}
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS, nil, rw::im3d::ALLOPAQUE);
|
|
rw::im3d::RenderPrimitive(rw::PRIMTYPEPOLYLINE);
|
|
rw::im3d::RenderLine(NUMVERTS-1, 0);
|
|
rw::im3d::End();
|
|
}
|
|
|
|
void
|
|
DrawCone(float coneAngle, float coneSize, float coneRatio)
|
|
{
|
|
enum { NUMVERTS = 10 };
|
|
rw::RWDEVICE::Im3DVertex shape[NUMVERTS+1];
|
|
rw::int16 indices[NUMVERTS*3];
|
|
rw::int32 i;
|
|
|
|
rw::Matrix *matrix = CurrentLight->getFrame()->getLTM();
|
|
rw::V3d *pos = &matrix->pos;
|
|
|
|
// cone
|
|
for(i = 1; i < NUMVERTS+1; i++){
|
|
float cosValue = cosf(i/(NUMVERTS/2.0f) * M_PI) *
|
|
sinf(coneAngle/180.0f*M_PI);
|
|
float sinValue = sinf(i/(NUMVERTS/2.0f) * M_PI) *
|
|
sinf(coneAngle/180.0f*M_PI);
|
|
|
|
float coneAngleD = cosf(coneAngle/180.0f*M_PI);
|
|
|
|
rw::V3d up = rw::scale(matrix->up, sinValue*coneSize);
|
|
rw::V3d right = rw::scale(matrix->right, cosValue*coneSize);
|
|
rw::V3d at = rw::scale(matrix->at, coneAngleD*coneSize*coneRatio);
|
|
|
|
shape[i].setX(pos->x + at.x + up.x + right.x);
|
|
shape[i].setY(pos->y + at.y + up.y + right.y);
|
|
shape[i].setZ(pos->z + at.z + up.z + right.z);
|
|
}
|
|
|
|
for(i = 0; i < NUMVERTS; i++){
|
|
indices[i*3 + 0] = 0;
|
|
indices[i*3 + 1] = i+2;
|
|
indices[i*3 + 2] = i+1;
|
|
}
|
|
indices[NUMVERTS*3-2] = 1;
|
|
|
|
for(i = 0; i < NUMVERTS+1; i++)
|
|
shape[i].setColor(LightSolidColor.red, LightSolidColor.green,
|
|
LightSolidColor.blue, 128);
|
|
|
|
shape[0].setX(pos->x);
|
|
shape[0].setY(pos->y);
|
|
shape[0].setZ(pos->z);
|
|
|
|
rw::SetRenderState(rw::VERTEXALPHA, 1);
|
|
rw::SetRenderState(rw::SRCBLEND, rw::BLENDSRCALPHA);
|
|
rw::SetRenderState(rw::DESTBLEND, rw::BLENDINVSRCALPHA);
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS+1, nil, 0);
|
|
rw::im3d::RenderPrimitive(rw::PRIMTYPETRIFAN);
|
|
rw::im3d::RenderTriangle(0, NUMVERTS, 1);
|
|
rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indices, NUMVERTS*3);
|
|
rw::im3d::End();
|
|
|
|
|
|
for(i = 0; i < NUMVERTS+1; i++)
|
|
shape[i].setColor(LightSolidColor.red, LightSolidColor.green,
|
|
LightSolidColor.blue, 255);
|
|
|
|
float coneAngleD = cosf(coneAngle/180.0f*M_PI);
|
|
rw::V3d at = rw::scale(matrix->at, coneAngleD*coneSize*coneRatio);
|
|
shape[0].setX(pos->x + at.x);
|
|
shape[0].setY(pos->y + at.y);
|
|
shape[0].setZ(pos->z + at.z);
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS+1, nil, rw::im3d::ALLOPAQUE);
|
|
if(coneRatio > 0.0f){
|
|
rw::im3d::RenderPrimitive(rw::PRIMTYPETRIFAN);
|
|
rw::im3d::RenderTriangle(0, NUMVERTS, 1);
|
|
}else
|
|
rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRIFAN, indices, NUMVERTS*3);
|
|
rw::im3d::End();
|
|
|
|
|
|
// lines
|
|
at = rw::scale(matrix->at, -0.05f);
|
|
shape[0].setX(pos->x + at.x);
|
|
shape[0].setY(pos->y + at.y);
|
|
shape[0].setZ(pos->z + at.z);
|
|
rw::im3d::Transform(shape, NUMVERTS+1, nil, rw::im3d::ALLOPAQUE);
|
|
rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPEPOLYLINE, indices, NUMVERTS*3);
|
|
rw::im3d::End();
|
|
}
|
|
|
|
void
|
|
DrawDirectLight(void)
|
|
{
|
|
enum { NUMVERTS = 20 };
|
|
const float DIAMETER = 1.5f;
|
|
const float CONE_ANGLE = 45.0f;
|
|
const float CONE_SIZE = 3.0f;
|
|
const float LENGTH = 5.0f;
|
|
rw::RWDEVICE::Im3DVertex shape[NUMVERTS*2+1];
|
|
rw::int16 indices[NUMVERTS*3];
|
|
rw::int32 i;
|
|
|
|
rw::Matrix *matrix = CurrentLight->getFrame()->getLTM();
|
|
rw::V3d *pos = &matrix->pos;
|
|
|
|
// cylinder
|
|
for(i = 0; i < NUMVERTS*2; i += 2){
|
|
float cosValue = cosf(i/(NUMVERTS/2.0f) * M_PI);
|
|
float sinValue = sinf(i/(NUMVERTS/2.0f) * M_PI);
|
|
|
|
rw::V3d up = rw::scale(matrix->up, sinValue*DIAMETER);
|
|
rw::V3d right = rw::scale(matrix->right, cosValue*DIAMETER);
|
|
rw::V3d at = rw::scale(matrix->at, -(CONE_SIZE + 1.0f));
|
|
|
|
shape[i].setX(pos->x + at.x + up.x + right.x);
|
|
shape[i].setY(pos->y + at.y + up.y + right.y);
|
|
shape[i].setZ(pos->z + at.z + up.z + right.z);
|
|
|
|
|
|
at = rw::scale(matrix->at, -(LENGTH + CONE_SIZE));
|
|
|
|
shape[i+1].setX(pos->x + at.x + up.x + right.x);
|
|
shape[i+1].setY(pos->y + at.y + up.y + right.y);
|
|
shape[i+1].setZ(pos->z + at.z + up.z + right.z);
|
|
}
|
|
|
|
for(i = 0; i < NUMVERTS*2+1; i++)
|
|
shape[i].setColor(LightSolidColor.red, LightSolidColor.green,
|
|
LightSolidColor.blue, 128);
|
|
|
|
rw::SetRenderState(rw::VERTEXALPHA, 1);
|
|
rw::SetRenderState(rw::SRCBLEND, rw::BLENDSRCALPHA);
|
|
rw::SetRenderState(rw::DESTBLEND, rw::BLENDINVSRCALPHA);
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS*2, nil, 0);
|
|
rw::im3d::RenderPrimitive(rw::PRIMTYPETRISTRIP);
|
|
rw::im3d::RenderTriangle(2*NUMVERTS-2, 2*NUMVERTS-1, 0);
|
|
rw::im3d::RenderTriangle(2*NUMVERTS-1, 1, 0);
|
|
rw::im3d::End();
|
|
|
|
|
|
// bottom cap
|
|
for(i = 0; i < NUMVERTS*2+1; i++)
|
|
shape[i].setColor(LightSolidColor.red, LightSolidColor.green,
|
|
LightSolidColor.blue, 255);
|
|
|
|
rw::V3d at = rw::scale(matrix->at, -(LENGTH + CONE_SIZE));
|
|
shape[NUMVERTS*2].setX(pos->x + at.x);
|
|
shape[NUMVERTS*2].setY(pos->y + at.y);
|
|
shape[NUMVERTS*2].setZ(pos->z + at.z);
|
|
|
|
for(i = 0; i < NUMVERTS; i++){
|
|
indices[i*3+0] = NUMVERTS*2;
|
|
indices[i*3+1] = (i+1)*2 + 1;
|
|
indices[i*3+2] = i*2 + 1;
|
|
}
|
|
indices[NUMVERTS*3-2] = 1;
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS*2+1, nil, rw::im3d::ALLOPAQUE);
|
|
rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indices, NUMVERTS*3);
|
|
rw::im3d::End();
|
|
|
|
|
|
// top cap
|
|
at = rw::scale(matrix->at, -(CONE_SIZE + 1.0f));
|
|
shape[NUMVERTS*2].setX(pos->x + at.x);
|
|
shape[NUMVERTS*2].setY(pos->y + at.y);
|
|
shape[NUMVERTS*2].setZ(pos->z + at.z);
|
|
|
|
for(i = 0; i < NUMVERTS; i++){
|
|
indices[i*3+0] = NUMVERTS*2;
|
|
indices[i*3+1] = i*2;
|
|
indices[i*3+2] = (i+1)*2;
|
|
}
|
|
|
|
rw::im3d::Transform(shape, NUMVERTS*2+1, nil, rw::im3d::ALLOPAQUE);
|
|
rw::im3d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST, indices, NUMVERTS*3);
|
|
rw::im3d::End();
|
|
|
|
|
|
// cone
|
|
DrawCone(CONE_ANGLE, CONE_SIZE, -2.0f);
|
|
}
|
|
|
|
void
|
|
DrawCurrentLight(void)
|
|
{
|
|
rw::SetRenderState(rw::TEXTURERASTER, nil);
|
|
rw::SetRenderState(rw::CULLMODE, rw::CULLBACK);
|
|
rw::SetRenderState(rw::ZTESTENABLE, 1);
|
|
|
|
switch(LightTypeIndex){
|
|
case 1: DrawPointLight(); break;
|
|
case 2: DrawDirectLight(); break;
|
|
case 3:
|
|
case 4: DrawCone(LightConeAngle, LightRadius*POINT_LIGHT_RADIUS_FACTOR, 1.0f); break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void
|
|
LightRotate(float xAngle, float yAngle)
|
|
{
|
|
if(CurrentLight == nil || CurrentLight == AmbientLight || CurrentLight == PointLight)
|
|
return;
|
|
|
|
rw::Matrix *cameraMatrix = &Camera->getFrame()->matrix;
|
|
rw::Frame *lightFrame = CurrentLight->getFrame();
|
|
rw::V3d pos = lightFrame->matrix.pos;
|
|
|
|
pos = rw::scale(pos, -1.0f);
|
|
lightFrame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
|
|
lightFrame->rotate(&cameraMatrix->up, xAngle, rw::COMBINEPOSTCONCAT);
|
|
lightFrame->rotate(&cameraMatrix->right, yAngle, rw::COMBINEPOSTCONCAT);
|
|
|
|
pos = rw::scale(pos, -1.0f);
|
|
lightFrame->translate(&pos, rw::COMBINEPOSTCONCAT);
|
|
}
|
|
|
|
void
|
|
ClampPosition(rw::V3d *pos, rw::V3d *delta, rw::BBox *bbox)
|
|
{
|
|
if(pos->x + delta->x < bbox->inf.x)
|
|
delta->x = bbox->inf.x - pos->x;
|
|
else if(pos->x + delta->x > bbox->sup.x)
|
|
delta->x = bbox->sup.x - pos->x;
|
|
|
|
if(pos->y + delta->y < bbox->inf.y)
|
|
delta->y = bbox->inf.y - pos->y;
|
|
else if(pos->y + delta->y > bbox->sup.y)
|
|
delta->y = bbox->sup.y - pos->y;
|
|
|
|
if(pos->z + delta->z < bbox->inf.z)
|
|
delta->z = bbox->inf.z - pos->z;
|
|
else if(pos->z + delta->z > bbox->sup.z)
|
|
delta->z = bbox->sup.z - pos->z;
|
|
}
|
|
|
|
void
|
|
LightTranslateXY(float xDelta, float yDelta)
|
|
{
|
|
if(CurrentLight == nil || CurrentLight == AmbientLight || CurrentLight == DirectLight)
|
|
return;
|
|
|
|
rw::Matrix *cameraMatrix = &Camera->getFrame()->matrix;
|
|
rw::Frame *lightFrame = CurrentLight->getFrame();
|
|
rw::V3d right = rw::scale(cameraMatrix->right, xDelta);
|
|
rw::V3d up = rw::scale(cameraMatrix->up, yDelta);
|
|
rw::V3d delta = rw::add(right, up);
|
|
|
|
ClampPosition(&lightFrame->matrix.pos, &delta, &RoomBBox);
|
|
|
|
lightFrame->translate(&delta, rw::COMBINEPOSTCONCAT);
|
|
}
|
|
|
|
void
|
|
LightTranslateZ(float zDelta)
|
|
{
|
|
if(CurrentLight == nil || CurrentLight == AmbientLight || CurrentLight == DirectLight)
|
|
return;
|
|
|
|
rw::Matrix *cameraMatrix = &Camera->getFrame()->matrix;
|
|
rw::Frame *lightFrame = CurrentLight->getFrame();
|
|
rw::V3d delta = rw::scale(cameraMatrix->at, zDelta);
|
|
|
|
ClampPosition(&lightFrame->matrix.pos, &delta, &RoomBBox);
|
|
|
|
lightFrame->translate(&delta, rw::COMBINEPOSTCONCAT);
|
|
}
|
|
*/ |