random-mirrors
/
librw
mirror of https://github.com/aap/librw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

subrast example

This commit is contained in:
aap 2021-03-03 16:43:20 +01:00
parent d13bd898fe
commit 47487afc04
12 changed files with 1065 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
premake5.lua
View File

@ -209,6 +209,14 @@ project "lights"
removeplatforms { "*null" }
removeplatforms { "ps2" }
project "subrast"
kind "WindowedApp"
characterset ("MBCS")
skeltool("subrast")
flags { "WinMain" }
removeplatforms { "*null" }
removeplatforms { "ps2" }
project "ska2anm"
kind "ConsoleApp"
characterset ("MBCS")

4
skeleton/skeleton.cpp
View File

@ -47,6 +47,8 @@ InitRW(void)
if(!rw::Engine::start())
return false;
rw::Charset::open();
rw::Image::setSearchPath("./");
return true;
}
@ -54,6 +56,8 @@ InitRW(void)
void
TerminateRW(void)
{
rw::Charset::close();
// TODO: delete all tex dicts
rw::Engine::stop();
rw::Engine::close();

8
src/charset.cpp
View File

@ -128,8 +128,16 @@ Charset::flushBuffer(void)
rw::SetRenderState(rw::TEXTUREADDRESS, rw::Texture::WRAP);
rw::SetRenderState(rw::TEXTUREFILTER, rw::Texture::NEAREST);
uint32 cull = rw::GetRenderState(rw::CULLMODE);
uint32 ztest = rw::GetRenderState(rw::ZTESTENABLE);
rw::SetRenderState(rw::CULLMODE, rw::CULLNONE);
rw::SetRenderState(rw::ZTESTENABLE, 0);
im2d::RenderIndexedPrimitive(rw::PRIMTYPETRILIST,
vertices, numChars*4, indices, numChars*6);
rw::SetRenderState(rw::CULLMODE, cull);
rw::SetRenderState(rw::ZTESTENABLE, ztest);
}
numChars = 0;

2
src/d3d/d3d.cpp
View File

@ -18,7 +18,7 @@
namespace rw {
namespace d3d {
bool32 isP8supported = 1;
bool32 isP8supported = 1; // set to 0 when actual d3d device is used
// stolen from d3d8to9
static uint32

36
src/d3d/d3ddevice.cpp
View File

@ -944,6 +944,9 @@ setRenderSurfaces(Camera *cam)
Raster *fbuf = cam->frameBuffer;
assert(fbuf);
{
if(fbuf->parent)
fbuf = fbuf->parent;
D3dRaster *natras = GETD3DRASTEREXT(fbuf);
assert(fbuf->type == Raster::CAMERA || fbuf->type == Raster::CAMERATEXTURE);
if(natras->texture == nil)
@ -959,6 +962,9 @@ setRenderSurfaces(Camera *cam)
Raster *zbuf = cam->zBuffer;
if(zbuf){
if(zbuf->parent)
zbuf = zbuf->parent;
D3dRaster *natras = GETD3DRASTEREXT(zbuf);
assert(zbuf->type == Raster::ZBUFFER);
setDepthSurface(natras->texture);
@ -967,6 +973,19 @@ setRenderSurfaces(Camera *cam)
}
static void
setViewport(Raster *fb)
{
D3DVIEWPORT9 vp;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
vp.X = fb->offsetX;
vp.Y = fb->offsetY;
vp.Width = fb->width;
vp.Height = fb->height;
d3ddevice->SetViewport(&vp);
}
static void
beginUpdate(Camera *cam)
{
@ -1046,23 +1065,14 @@ beginUpdate(Camera *cam)
setRenderSurfaces(cam);
D3DVIEWPORT9 vp;
vp.MinZ = 0.0f;
vp.MaxZ = 1.0f;
vp.X = cam->frameBuffer->offsetX;
vp.Y = cam->frameBuffer->offsetY;
vp.Width = cam->frameBuffer->width;
vp.Height = cam->frameBuffer->height;
d3ddevice->SetViewport(&vp);
setViewport(cam->frameBuffer);
// TODO: figure out when to call this
d3ddevice->BeginScene();
}
static void
endUpdate(Camera *cam)
{
// TODO: figure out when to call this
d3ddevice->EndScene();
}
@ -1314,7 +1324,6 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
RECT r;
GetClientRect(d3d9Globals.window, &r);
BOOL icon = IsIconic(d3d9Globals.window);
Raster *ras = cam->frameBuffer;
if(!icon &&
(r.right != d3d9Globals.present.BackBufferWidth || r.bottom != d3d9Globals.present.BackBufferHeight)){
@ -1328,7 +1337,8 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
setRenderSurfaces(cam);
d3ddevice->Clear(0, 0, mode, c, 1.0f, 0);
setViewport(cam->frameBuffer); // need to set this for the clear to work correctly
d3ddevice->Clear(0, nil, mode, c, 1.0f, 0);
}
static void
@ -1604,6 +1614,8 @@ startD3D(void)
// d3d9Globals.present.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
d3d9Globals.present.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
rw::d3d::isP8supported = 0;
assert(d3d::d3ddevice == nil);
BOOL icon = IsIconic(d3d9Globals.window);

102
src/gl/gl3device.cpp
View File

@ -1225,6 +1225,50 @@ setFrameBuffer(Camera *cam)
}
}
static Rect
getFramebufferRect(Raster *frameBuffer)
{
Rect r;
Raster *fb = frameBuffer->parent;
if(fb->type == Raster::CAMERA){
#ifdef LIBRW_SDL2
SDL_GetWindowSize(glGlobals.window, &r.w, &r.h);
#else
glfwGetFramebufferSize(glGlobals.window, &r.w, &r.h);
#endif
}else{
r.w = fb->width;
r.h = fb->height;
}
r.x = 0;
r.y = 0;
// Got a subraster
if(frameBuffer != fb){
r.x = frameBuffer->offsetX;
// GL y offset is from bottom
r.y = r.h - frameBuffer->height - frameBuffer->offsetY;
r.w = frameBuffer->width;
r.h = frameBuffer->height;
}
return r;
}
static void
setViewport(Raster *frameBuffer)
{
Rect r = getFramebufferRect(frameBuffer);
if(r.w != glGlobals.presentWidth || r.h != glGlobals.presentHeight ||
r.x != glGlobals.presentOffX || r.y != glGlobals.presentOffY){
glViewport(r.x, r.y, r.w, r.h);
glGlobals.presentWidth = r.w;
glGlobals.presentHeight = r.h;
glGlobals.presentOffX = r.x;
glGlobals.presentOffY = r.y;
}
}
static void
beginUpdate(Camera *cam)
{
@ -1279,10 +1323,10 @@ beginUpdate(Camera *cam)
proj[14] = -2.0f*cam->nearPlane*cam->farPlane*invz;
proj[15] = 0.0f;
}else{
proj[10] = -(cam->farPlane+cam->nearPlane)*invz;
proj[10] = 2.0f*invz;
proj[11] = 0.0f;
proj[14] = 2.0f*invz;
proj[14] = -(cam->farPlane+cam->nearPlane)*invz;
proj[15] = 1.0f;
}
memcpy(&cam->devProj, &proj, sizeof(RawMatrix));
@ -1301,39 +1345,7 @@ beginUpdate(Camera *cam)
setFrameBuffer(cam);
int w, h;
int x, y;
Raster *fb = cam->frameBuffer->parent;
if(fb->type == Raster::CAMERA){
#ifdef LIBRW_SDL2
SDL_GetWindowSize(glGlobals.window, &w, &h);
#else
glfwGetFramebufferSize(glGlobals.window, &w, &h);
#endif
}else{
w = fb->width;
h = fb->height;
}
x = 0;
y = 0;
// Got a subraster
if(cam->frameBuffer != fb){
x = cam->frameBuffer->offsetX;
// GL y offset is from bottom
y = h - cam->frameBuffer->height - cam->frameBuffer->offsetY;
w = cam->frameBuffer->width;
h = cam->frameBuffer->height;
}
if(w != glGlobals.presentWidth || h != glGlobals.presentHeight ||
x != glGlobals.presentOffX || y != glGlobals.presentOffY){
glViewport(x, y, w, h);
glGlobals.presentWidth = w;
glGlobals.presentHeight = h;
glGlobals.presentOffX = x;
glGlobals.presentOffY = y;
}
setViewport(cam->frameBuffer);
}
static void
@ -1349,6 +1361,15 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
setFrameBuffer(cam);
// make sure we're only clearing the part of the framebuffer
// that is subrastered
bool setScissor = cam->frameBuffer != cam->frameBuffer->parent;
if(setScissor){
Rect r = getFramebufferRect(cam->frameBuffer);
glScissor(r.x, r.y, r.w, r.h);
glEnable(GL_SCISSOR_TEST);
}
convColor(&colf, col);
glClearColor(colf.red, colf.green, colf.blue, colf.alpha);
mask = 0;
@ -1361,12 +1382,17 @@ clearCamera(Camera *cam, RGBA *col, uint32 mode)
glDepthMask(GL_TRUE);
glClear(mask);
glDepthMask(rwStateCache.zwrite);
if(setScissor)
glDisable(GL_SCISSOR_TEST);
}
static void
showRaster(Raster *raster, uint32 flags)
{
// TODO: do this properly!
// glViewport(raster->offsetX, raster->offsetY,
// raster->width, raster->height);
#ifdef LIBRW_SDL2
if(flags & Raster::FLIPWAITVSYNCH)
SDL_GL_SetSwapInterval(1);
@ -1746,8 +1772,8 @@ initOpenGL(void)
// printf("%d %s\n", i, ext);
}
*/
gl3Caps.dxtSupported = GLAD_GL_EXT_texture_compression_s3tc;
gl3Caps.astcSupported = GLAD_GL_KHR_texture_compression_astc_ldr;
gl3Caps.dxtSupported = !!GLAD_GL_EXT_texture_compression_s3tc;
gl3Caps.astcSupported = !!GLAD_GL_KHR_texture_compression_astc_ldr;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl3Caps.maxAnisotropy);

4
src/raster.cpp
View File

@ -87,8 +87,8 @@ Raster::subRaster(Raster *parent, Rect *r)
return;
this->width = r->w;
this->height = r->h;
this->offsetX += r->x;
this->offsetY += r->y;
this->offsetX = parent->offsetX + r->x;
this->offsetY = parent->offsetY + r->y;
this->parent = parent->parent;
}

BIN
tools/subrast/files/clump.dff Normal file
View File

Binary file not shown.

BIN
tools/subrast/files/textures/whiteash.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.2 KiB

352
tools/subrast/main.cpp Normal file
View File

@ -0,0 +1,352 @@
#include <rw.h>
#include <skeleton.h>
#include <assert.h>
#include "subrast.h"
rw::V3d zero = { 0.0f, 0.0f, 0.0f };
rw::EngineOpenParams engineOpenParams;
float FOV = 70.0f;
rw::RGBA ForegroundColor = { 200, 200, 200, 255 };
rw::RGBA BackgroundColor = { 64, 64, 64, 0 };
rw::RGBA BorderColor = { 128, 128, 128, 0 };
rw::Clump *Clump = nil;
rw::Light *MainLight = nil;
rw::Light *AmbientLight = nil;
rw::World *World;
rw::Charset *Charset;
const char *SubCameraCaption[4] = {
"Perspective view",
"Parallel view: Z-axis",
"Parallel view: X-axis",
"Parallel view: Y-axis"
};
rw::V3d Xaxis = { 1.0f, 0.0, 0.0f };
rw::V3d Yaxis = { 0.0f, 1.0, 0.0f };
rw::V3d Zaxis = { 0.0f, 0.0, 1.0f };
rw::World*
CreateWorld(void)
{
rw::BBox bb;
bb.inf.x = bb.inf.y = bb.inf.z = -100.0f;
bb.sup.x = bb.sup.y = bb.sup.z = 100.0f;
return rw::World::create(&bb);
}
rw::Light*
CreateAmbientLight(rw::World *world)
{
rw::Light *light = rw::Light::create(rw::Light::AMBIENT);
assert(light);
World->addLight(light);
return light;
}
rw::Light*
CreateMainLight(rw::World *world)
{
rw::Light *light = rw::Light::create(rw::Light::DIRECTIONAL);
assert(light);
rw::Frame *frame = rw::Frame::create();
assert(frame);
frame->rotate(&Xaxis, 30.0f, rw::COMBINEREPLACE);
frame->rotate(&Yaxis, 30.0f, rw::COMBINEPOSTCONCAT);
light->setFrame(frame);
World->addLight(light);
return light;
}
rw::Clump*
CreateClump(rw::World *world)
{
rw::Clump *clump;
rw::StreamFile in;
rw::Image::setSearchPath("files/textures/");
const char *filename = "files/clump.dff";
if(in.open(filename, "rb") == NULL){
printf("couldn't open file\n");
return false;
}
if(!rw::findChunk(&in, rw::ID_CLUMP, NULL, NULL))
return false;
clump = rw::Clump::streamRead(&in);
in.close();
if(clump == nil)
return false;
rw::Frame *frame = clump->getFrame();
frame->rotate(&Xaxis, -120.0f, rw::COMBINEREPLACE);
frame->rotate(&Yaxis, 45.0f, rw::COMBINEPOSTCONCAT);
World->addClump(clump);
return clump;
}
void
RotateClump(float xAngle, float yAngle)
{
rw::Matrix *cameraMatrix = &Camera->getFrame()->matrix;
rw::Frame *frame = Clump->getFrame();
rw::V3d pos = frame->matrix.pos;
pos = rw::scale(pos, -1.0f);
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
frame->rotate(&cameraMatrix->up, xAngle, rw::COMBINEPOSTCONCAT);
frame->rotate(&cameraMatrix->right, yAngle, rw::COMBINEPOSTCONCAT);
pos = rw::scale(pos, -1.0f);
frame->translate(&pos, rw::COMBINEPOSTCONCAT);
}
void
Initialize(void)
{
sk::globals.windowtitle = "Sub-raster example";
sk::globals.width = 1280;
sk::globals.height = 800;
sk::globals.quit = 0;
}
bool
Initialize3D(void)
{
if(!sk::InitRW())
return false;
Charset = rw::Charset::create(&ForegroundColor, &BackgroundColor);
World = CreateWorld();
AmbientLight = CreateAmbientLight(World);
MainLight = CreateMainLight(World);
Clump = CreateClump(World);
CreateCameras(World);
UpdateSubRasters(Camera, sk::globals.width, sk::globals.height);
rw::SetRenderState(rw::CULLMODE, rw::CULLBACK);
rw::SetRenderState(rw::ZTESTENABLE, 1);
rw::SetRenderState(rw::ZWRITEENABLE, 1);
ImGui_ImplRW_Init();
ImGui::StyleColorsClassic();
return true;
}
void
Terminate3D(void)
{
DestroyCameras(World);
if(AmbientLight){
World->removeLight(AmbientLight);
AmbientLight->destroy();
AmbientLight = nil;
}
if(MainLight){
World->removeLight(MainLight);
rw::Frame *frame = MainLight->getFrame();
MainLight->setFrame(nil);
frame->destroy();
MainLight->destroy();
MainLight = nil;
}
if(Clump){
World->removeClump(Clump);
Clump->destroy();
Clump = nil;
}
if(World){
World->destroy();
World = nil;
}
if(Charset){
Charset->destroy();
Charset = nil;
}
sk::TerminateRW();
}
bool
attachPlugins(void)
{
rw::ps2::registerPDSPlugin(40);
rw::ps2::registerPluginPDSPipes();
rw::registerMeshPlugin();
rw::registerNativeDataPlugin();
rw::registerAtomicRightsPlugin();
rw::registerMaterialRightsPlugin();
rw::xbox::registerVertexFormatPlugin();
rw::registerSkinPlugin();
rw::registerUserDataPlugin();
rw::registerHAnimPlugin();
rw::registerMatFXPlugin();
rw::registerUVAnimPlugin();
rw::ps2::registerADCPlugin();
return true;
}
void
DisplayOnScreenInfo(void)
{
for(int i = 0; i < 4; i++){
rw::Raster *scr = SubCameras[i]->frameBuffer;
rw::int32 scrw = scr->width;
rw::int32 scrh = scr->height;
rw::int32 captionWidth = strlen(SubCameraCaption[i])*Charset->desc.width;
if(captionWidth < scrw && scrh > Charset->desc.height*2){
rw::int32 x = scr->offsetX + (scrw - captionWidth)/2;
rw::int32 y = scr->offsetY + Charset->desc.height;
Charset->print(SubCameraCaption[i], x, y, 0);
}
}
}
rw::RGBA BackgroundColors[] = {
{ 64, 64, 64, 0 },
{ 128, 0, 0, 0 },
{ 0, 128, 0, 0 },
{ 0, 0, 128, 0 },
};
void
Render(float timeDelta)
{
Camera->clear(&BorderColor, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
for(int i = 0; i < 4; i++){
SubCameras[i]->clear(&BackgroundColor, rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
// SubCameras[i]->clear(&BackgroundColors[i], rw::Camera::CLEARIMAGE|rw::Camera::CLEARZ);
SubCameras[i]->beginUpdate();
World->render();
SubCameras[i]->endUpdate();
}
Camera->beginUpdate();
DisplayOnScreenInfo();
Camera->endUpdate();
Camera->showRaster(0);
}
void
Idle(float timeDelta)
{
Render(timeDelta);
}
int MouseX, MouseY;
int MouseDeltaX, MouseDeltaY;
int MouseButtons;
bool Rotating;
void
KeyUp(int key)
{
}
void
KeyDown(int key)
{
switch(key){
case sk::KEY_ESC:
sk::globals.quit = 1;
break;
}
}
void
MouseBtn(sk::MouseState *mouse)
{
MouseButtons = mouse->buttons;
Rotating = !!(MouseButtons&1);
}
void
MouseMove(sk::MouseState *mouse)
{
MouseDeltaX = mouse->posx - MouseX;
MouseDeltaY = mouse->posy - MouseY;
MouseX = mouse->posx;
MouseY = mouse->posy;
if(Rotating)
RotateClump(-MouseDeltaX, MouseDeltaY);
}
sk::EventStatus
AppEventHandler(sk::Event e, void *param)
{
using namespace sk;
Rect *r;
MouseState *ms;
ImGuiEventHandler(e, param);
ImGuiIO &io = ImGui::GetIO();
switch(e){
case INITIALIZE:
Initialize();
return EVENTPROCESSED;
case RWINITIALIZE:
return Initialize3D() ? EVENTPROCESSED : EVENTERROR;
case RWTERMINATE:
Terminate3D();
return EVENTPROCESSED;
case PLUGINATTACH:
return attachPlugins() ? EVENTPROCESSED : EVENTERROR;
case KEYDOWN:
KeyDown(*(int*)param);
return EVENTPROCESSED;
case KEYUP:
KeyUp(*(int*)param);
return EVENTPROCESSED;
case MOUSEBTN:
if(!io.WantCaptureMouse){
ms = (MouseState*)param;
MouseBtn(ms);
}else
MouseButtons = 0;
return EVENTPROCESSED;
case MOUSEMOVE:
MouseMove((MouseState*)param);
return EVENTPROCESSED;
case RESIZE:
r = (Rect*)param;
// TODO: register when we're minimized
if(r->w == 0) r->w = 1;
if(r->h == 0) r->h = 1;
sk::globals.width = r->w;
sk::globals.height = r->h;
if(::Camera){
sk::CameraSize(::Camera, r);
::Camera->setFOV(FOV, (float)sk::globals.width/sk::globals.height);
UpdateSubRasters(::Camera, r->w, r->h);
}
break;
case IDLE:
Idle(*(float*)param);
return EVENTPROCESSED;
}
return sk::EVENTNOTPROCESSED;
}

592
tools/subrast/subrast.cpp Normal file
View File

@ -0,0 +1,592 @@
#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);
}
*/

10
tools/subrast/subrast.h Normal file
View File

@ -0,0 +1,10 @@
extern rw::Camera *Camera;
extern rw::Camera *SubCameras[4];
void CreateCameras(rw::World *world);
void DestroyCameras(rw::World *world);
void UpdateSubRasters(rw::Camera *mainCamera, rw::int32 mainWidth, rw::int32 mainHeight);
extern rw::V3d Xaxis;
extern rw::V3d Yaxis;
extern rw::V3d Zaxis;