704 lines
21 KiB
C++
704 lines
21 KiB
C++
#include "stdafx.h"
|
|
#include "RTView.h"
|
|
//#include "RCKRenderContext.h"
|
|
#include "CKRasterizer.h"
|
|
|
|
#define RENDERSCENE_GUID CKGUID(0x3f3c5b66,0x2ab81a45)
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Input parameters
|
|
enum
|
|
{
|
|
PARAM_VIEW = 0,
|
|
PARAM_RENDEROPTIONS,
|
|
PARAM_BGCOLOR,
|
|
PARAM_BGTEXTURE,
|
|
PARAM_CAMERA,
|
|
PARAM_FACEBYFACE,
|
|
PARAM_UPDATESYSTEMMEMORY,
|
|
PARAM_OVERIDINGMATERIAL,
|
|
PARAM_ORIENTATIONREFERENTIAL,
|
|
PARAM_OVERRIDETECHNIQUE,
|
|
PARAM_TECHNIQUENAME
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Settings
|
|
enum
|
|
{
|
|
PARAM_HOMOGENEOUSVIEW = 0,
|
|
PARAM_RTCOUNT,
|
|
PARAM_COUNT_PIXELS_USING_OCCLUSION_QUERY,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Output parameters
|
|
enum
|
|
{
|
|
PARAM_PIXELCOUNT = 0
|
|
};
|
|
|
|
#define MAXRT_COUNT 4
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void ConvertToFullSizeIfInvalid( RTView& rtview, CKRenderContext* rc=NULL, BOOL homogen=FALSE );
|
|
void ComputeViewRectFromCameraRatio( VxRect& oViewRect, CKCamera& iCam, VxRect& iWindowRect );
|
|
|
|
int GetCurrentRTCount( CKBehavior* beh )
|
|
{
|
|
int viewCount=1;
|
|
while( 1 ){
|
|
CKParameterIn* pin = beh->GetInputParameter( PARAM_VIEW + viewCount );
|
|
if( !pin || pin->GetGUID()!=CKPGUID_TEXTURE ) break;
|
|
++viewCount;
|
|
}
|
|
return viewCount;
|
|
}
|
|
|
|
|
|
static inline int AddSat(int lhs, int rhs)
|
|
{
|
|
if ((CKDWORD) lhs > 0x7ffffff) lhs = 0x7ffffff;
|
|
if ((CKDWORD) rhs > 0x7ffffff) lhs = 0x7ffffff;
|
|
return (rhs + lhs) < rhs ? 0x7fffffff : (rhs + lhs);
|
|
}
|
|
|
|
/***********************************************/
|
|
// MAIN
|
|
/***********************************************/
|
|
int RenderScene(const CKBehaviorContext& behcontext)
|
|
{
|
|
CKBehavior* beh = behcontext.Behavior;
|
|
|
|
//--- Get Previous View Count
|
|
int decal = GetCurrentRTCount( beh )-1;
|
|
|
|
beh->ActivateInput(0, FALSE);
|
|
beh->ActivateOutput(0);
|
|
|
|
CKParameterIn* pin = beh->GetInputParameter( PARAM_VIEW );
|
|
if( !pin || !pin->GetRealSource() ) return CKBR_PARAMETERERROR;
|
|
|
|
//--- Read Final RT View
|
|
RTView rtview( pin->GetRealSource() );
|
|
|
|
// If no texture given, render in current backbuffer
|
|
|
|
//--- Check if user want to see texture in system memory
|
|
CKBOOL updateSystem = FALSE;
|
|
beh->GetInputParameterValue(decal+PARAM_UPDATESYSTEMMEMORY, &updateSystem );
|
|
|
|
//--- Force upload to video memory
|
|
CKRenderContext* rc = behcontext.CurrentRenderContext;
|
|
|
|
if (rtview.tex)
|
|
{
|
|
rtview.tex->EnsureVideoMemory(rc);
|
|
}
|
|
|
|
int pixelCount = 0;
|
|
|
|
CKBOOL countPixels = FALSE;
|
|
// TMP TMP : for next version only
|
|
//beh->GetLocalParameterValue(PARAM_COUNT_PIXELS_USING_OCCLUSION_QUERY, &countPixels);
|
|
|
|
//--- View Rect is homogeneous ?
|
|
BOOL homogen = FALSE;
|
|
beh->GetLocalParameterValue( PARAM_HOMOGENEOUSVIEW, &homogen );
|
|
|
|
//--- Get Wanted Render Options
|
|
CKDWORD prevropt = rc->GetCurrentRenderOptions();
|
|
CKDWORD ropt = prevropt;
|
|
beh->GetInputParameterValue(decal+PARAM_RENDEROPTIONS, &ropt );
|
|
|
|
//--- Check Rect size
|
|
CKCamera* oldCam = rc->GetAttachedCamera();
|
|
|
|
if( ropt&CK_RENDER_USECAMERARATIO ){
|
|
homogen = TRUE;
|
|
VxRect texRect( 0, 0, 256, 256 );
|
|
if( rtview.tex )
|
|
{
|
|
texRect.SetCorners( 0.0f, 0.0f, (float)rtview.tex->GetWidth(), (float)rtview.tex->GetHeight() );
|
|
}
|
|
else
|
|
{
|
|
texRect.SetCorners( 0.0f, 0.0f, (float)rc->GetWidth(), (float)rc->GetHeight() );
|
|
}
|
|
ComputeViewRectFromCameraRatio( rtview.rect, *oldCam, texRect );
|
|
}
|
|
ConvertToFullSizeIfInvalid( rtview, rc, homogen );
|
|
|
|
//--- Remove present command
|
|
ropt &= ~CK_RENDER_DOBACKTOFRONT;
|
|
|
|
//--- Set Render Target and View Rect
|
|
VxRect oldRect;
|
|
rc->GetViewRect( oldRect );
|
|
|
|
VxMatrix oldViewMat;
|
|
oldViewMat = rc->GetViewTransformationMatrix();
|
|
|
|
int currentRTCount = GetCurrentRTCount(beh);
|
|
|
|
if (currentRTCount > 1)
|
|
{
|
|
// special case : OpenGL + multisampling + MRT -> slow downs on nVidia quadro FX, plus some output color are missed.
|
|
// Can be solved by forcing an offscreen multisampled buffer, though. (not very elegant, but better than incorrect rendering)
|
|
CKRST_RSTFAMILY driverFamily = rc->GetRasterizerContext()->m_Driver->m_2DCaps.Family;
|
|
if (driverFamily == CKRST_OPENGL)
|
|
{
|
|
if (rc->GetRasterizerContext()->m_Antialias > 0)
|
|
{
|
|
behcontext.Context->GetVariableManager()->SetValue("CK2_3D/OffscreenMultiSampledBuffer", 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
CKRenderContext* rrc = rc;
|
|
CKTexture* leftEye = rtview.tex;
|
|
CKTexture* rightEye = rtview.tex ? rrc->GetStereoTextureRightEye(rtview.tex) : NULL;
|
|
CKBOOL stereo = (currentRTCount == 1 && leftEye && rightEye);
|
|
|
|
if(!stereo && rtview.tex && !rtview.tex->IsCubeMap() ){
|
|
|
|
rc->SetRenderTarget( rtview.tex );
|
|
|
|
if(currentRTCount>1){
|
|
int rtIndex = 1;
|
|
for(int i=PARAM_VIEW+1;i<PARAM_VIEW+currentRTCount;i++){
|
|
|
|
CKTexture *tex = (CKTexture *) beh->GetInputParameterObject(i);
|
|
rc->SetRenderTarget(tex, rtIndex++);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
rc->SetViewRect( rtview.rect );
|
|
|
|
//--- Get Desired camera
|
|
CKCamera* cam = (CKCamera*)beh->GetInputParameterObject(decal+ PARAM_CAMERA );
|
|
if( !cam ){
|
|
if( oldCam ){
|
|
cam = oldCam;
|
|
} else {
|
|
rc->GetCKContext()->OutputToConsole("Render Scene In RTView BB: There is no camera attached to the Render Context");
|
|
return CKBR_GENERICERROR;
|
|
}
|
|
}
|
|
|
|
DWORD prevCamFlag = cam->GetFlags();
|
|
|
|
//--- Prevent AttachViewpointToCamera() to override our nice ViewRect
|
|
cam->SetFlags(prevCamFlag & ~CK_3DENTITY_CAMERAIGNOREASPECT);
|
|
|
|
rc->AttachViewpointToCamera( cam );
|
|
|
|
cam->SetFlags(prevCamFlag);
|
|
|
|
|
|
//--- Set Background Material's Texture And Color
|
|
CKMaterial* bgMat = rc->GetBackgroundMaterial();
|
|
|
|
VxColor oldBgColor = bgMat->GetDiffuse();
|
|
VxColor bgColor(0,0,0,0);
|
|
beh->GetInputParameterValue(decal+PARAM_BGCOLOR, &bgColor );
|
|
bgMat->SetDiffuse( bgColor );
|
|
|
|
CKTexture* oldBgTex = bgMat->GetTexture();
|
|
CKTexture* bgTex = (CKTexture*)beh->GetInputParameterObject(decal+PARAM_BGTEXTURE );
|
|
bgMat->SetTexture( bgTex );
|
|
|
|
//--- Get Overiding Material
|
|
CKMaterial* overidingMaterial = (CKMaterial*)beh->GetInputParameterObject(decal+PARAM_OVERIDINGMATERIAL );
|
|
CKBOOL overrideTechnique = FALSE;
|
|
beh->GetInputParameterValue(PARAM_OVERRIDETECHNIQUE, &overrideTechnique);
|
|
if (overrideTechnique)
|
|
{
|
|
rc->SetOverriddenRendering( CK_OVERRIDE_TECHNIQUE, overidingMaterial, (const char*) beh->GetInputParameterReadDataPtr(PARAM_TECHNIQUENAME));
|
|
}
|
|
else
|
|
{
|
|
if( overidingMaterial ) rc->SetOverriddenRendering( CK_OVERRIDE_MATERIAL, overidingMaterial );
|
|
}
|
|
|
|
CK3dEntity* orientRef = (CK3dEntity*)beh->GetInputParameterObject( decal+PARAM_ORIENTATIONREFERENTIAL );
|
|
|
|
CK_RENDER_FLAGS oldRopt = (CK_RENDER_FLAGS) rc->GetCurrentRenderOptions();
|
|
rc->SetCurrentRenderOptions(ropt);
|
|
//--- If Render Target is a Cube Map
|
|
if(rtview.tex && rtview.tex->IsCubeMap() ){
|
|
//--- Compute the 6 Rotation Matrices
|
|
VxMatrix Rotation[6]= {VxMatrix::Identity(),VxMatrix::Identity(),VxMatrix::Identity()
|
|
,VxMatrix::Identity(),VxMatrix::Identity(),VxMatrix::Identity() };
|
|
|
|
//----- Referential directed to X axis
|
|
Rotation[0][0].Set(0.0f ,0.0f ,-1.0f ,0.0f);
|
|
Rotation[0][2].Set(1.0f ,0.0f , 0.0f ,0.0f);
|
|
//----- Referential directed to -X axis
|
|
Rotation[1][0].Set(0.0f ,0.0f , 1.0f ,0.0f);
|
|
Rotation[1][2].Set(-1.0f,0.0f , 0.0f ,0.0f);
|
|
//----- Referential directed to Y axis
|
|
Rotation[2][1].Set(0.0f ,0.0f ,-1.0f ,0.0f);
|
|
Rotation[2][2].Set(0.0f, 1.0f , 0.0f ,0.0f);
|
|
//----- Referential directed to -Y axis
|
|
Rotation[3][1].Set(0.0f ,0.0f , 1.0f ,0.0f);
|
|
Rotation[3][2].Set(0.0f,-1.0f , 0.0f ,0.0f);
|
|
//----- Referential directed to Z axis
|
|
//----- Referential directed to -Z axis
|
|
Rotation[5][0].Set(-1.0f,0.0f , 0.0f ,0.0f);
|
|
Rotation[5][2].Set( 0.0f,0.0f ,-1.0f ,0.0f);
|
|
|
|
BOOL RenderFaceByFace = FALSE;
|
|
beh->GetInputParameterValue(decal+PARAM_FACEBYFACE, &RenderFaceByFace );
|
|
|
|
//--- Storing Previous Camera Fov / Aspect Ratio / Target
|
|
float oldFov = cam->GetFov();
|
|
int asx,asy;
|
|
cam->GetAspectRatio( asx, asy );
|
|
CK3dEntity* oldTargetCam = cam->GetTarget();
|
|
|
|
//--- Setting Camera Fov / Aspect Ratio adapted for CubeMap generation
|
|
cam->SetFov( PI/2.0f );
|
|
cam->SetAspectRatio( 1, 1 );
|
|
cam->SetTarget( NULL );
|
|
|
|
//--- Storing Previous Camera World Matrix
|
|
VxMatrix OldCamMat = cam->GetWorldMatrix();
|
|
VxMatrix OrientRefMat;
|
|
if (orientRef)
|
|
OrientRefMat = orientRef->GetWorldMatrix();
|
|
VxVector Pos = OldCamMat[3];
|
|
|
|
// Special case : OpenGL + multisampling + Render into cubemap -> unsupported by FBO of some nVidia GPUs for that combination
|
|
CKBOOL skipRender = FALSE;
|
|
CKRST_RSTFAMILY driverFamily = rc->GetRasterizerContext()->m_Driver->m_2DCaps.Family;
|
|
if (driverFamily == CKRST_OPENGL)
|
|
{
|
|
if (rc->GetRasterizerContext()->m_Antialias > 0)
|
|
{
|
|
behcontext.Context->GetVariableManager()->SetValue("CK2_3D/OffscreenMultiSampledBuffer", 1);
|
|
// don't do the render right now (the device will be recreated)
|
|
skipRender = TRUE; // don't want to trigger an error ...
|
|
}
|
|
}
|
|
|
|
if (!skipRender)
|
|
{
|
|
//--- Render Face by Face ?
|
|
if( RenderFaceByFace ){
|
|
|
|
int Current = rtview.tex->GetCurrentSlot();
|
|
|
|
//--- Set Camera's Orientation adapted for CubeMap
|
|
if( orientRef ) Rotation[Current] = OrientRefMat * Rotation[Current];
|
|
Rotation[Current][3] = Pos;
|
|
cam->SetWorldMatrix( Rotation[Current] );
|
|
|
|
if( rc->SetRenderTarget(rtview.tex,Current) ){
|
|
|
|
//--- Render scene and update to system memory if needed
|
|
rc->Render((CK_RENDER_FLAGS)ropt);
|
|
|
|
if( updateSystem ) rtview.tex->VideoToSystemMemory();
|
|
}
|
|
//--- Increment CubeMap Slot
|
|
rtview.tex->SetCurrentSlot((Current+1)%6);
|
|
|
|
//--- Otherwise Render All Faces At Once
|
|
} else {
|
|
|
|
for( int a=0 ; a<6 ; ++a ){
|
|
|
|
//--- Set Camera's Orientation adapted for CubeMap
|
|
if( orientRef ) Rotation[a] = OrientRefMat * Rotation[a];
|
|
Rotation[a][3] = Pos;
|
|
cam->SetWorldMatrix( Rotation[a] );
|
|
|
|
if( rc->SetRenderTarget(rtview.tex,a) ) {
|
|
|
|
if (countPixels)
|
|
{
|
|
rc->GetRasterizerContext()->BeginOcclusionQuery();
|
|
}
|
|
|
|
//--- Render scene and update to system memory if needed
|
|
rc->Render((CK_RENDER_FLAGS)ropt);
|
|
|
|
if (countPixels)
|
|
{
|
|
pixelCount = AddSat(pixelCount, rc->GetRasterizerContext()->WaitOcclusionQueryResult());
|
|
}
|
|
|
|
if( updateSystem ) rtview.tex->VideoToSystemMemory();
|
|
|
|
//--- Restore rendering to default
|
|
rc->SetRenderTarget(NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--- Restore Camera
|
|
cam->SetWorldMatrix( OldCamMat );
|
|
cam->SetFov( oldFov );
|
|
cam->SetAspectRatio( asx, asy );
|
|
cam->SetTarget( oldTargetCam );
|
|
|
|
//--- If Render Target is not a Cube Map
|
|
} else {
|
|
//--- Render scene and update to system memory if needed
|
|
|
|
if (countPixels)
|
|
{
|
|
rc->GetRasterizerContext()->BeginOcclusionQuery();
|
|
}
|
|
//--- Render scene and update to system memory if needed
|
|
CKBOOL rightEyeRendered = FALSE;
|
|
if (stereo)
|
|
{
|
|
// it is a stereo texture -> render both eyes
|
|
if (rc->GetRasterizerContext()->m_Driver->m_Stereo || behcontext.Context->WillRenderBothStereoEyes())
|
|
{
|
|
rrc->_MatchStereoTextureRightToLeft(*leftEye, *rightEye);
|
|
// render both eyes
|
|
CKRenderContext::CK_STEREO_MODE oldStereoMode = rrc->GetStereoRenderMode();
|
|
rrc->SetRenderTarget(leftEye);
|
|
rc->SetViewRect( rtview.rect );
|
|
rrc->SetStereoRenderMode(CKRenderContext::CK_STEREO_LEFT);
|
|
rrc->Render( (CK_RENDER_FLAGS)ropt );
|
|
rrc->SetRenderTarget( NULL );
|
|
if (!rightEye->IsInVideoMemory())
|
|
{
|
|
rightEye->EnsureVideoMemory(rc);
|
|
}
|
|
rrc->SetRenderTarget(rightEye);
|
|
rc->SetViewRect( rtview.rect );
|
|
rrc->SetStereoRenderMode(CKRenderContext::CK_STEREO_RIGHT);
|
|
rrc->Render( (CK_RENDER_FLAGS)ropt );
|
|
rrc->SetStereoRenderMode(oldStereoMode);
|
|
rightEyeRendered = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// use wanted eye
|
|
rrc->SetRenderTarget(rrc->GetStereoRenderMode() == CKRenderContext::CK_STEREO_RIGHT ? rightEye : leftEye);
|
|
rrc->Render( (CK_RENDER_FLAGS)ropt );
|
|
if (rrc->GetStereoRenderMode() == CKRenderContext::CK_STEREO_RIGHT)
|
|
{
|
|
rightEyeRendered = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// bugfix : force non-stereo rendering for non stereo textures (always ...)
|
|
// (unless we are rendering to the main frame buffer -> must retain current stereo settings in this case)
|
|
CKRenderContext::CK_STEREO_MODE oldStereoMode = rrc->GetStereoRenderMode();
|
|
if (oldStereoMode != CKRenderContext::CK_STEREO_DEFAULT && rtview.tex != NULL)
|
|
{
|
|
rrc->SetStereoRenderMode(CKRenderContext::CK_STEREO_DEFAULT);
|
|
rrc->Render( (CK_RENDER_FLAGS)ropt );
|
|
rrc->SetStereoRenderMode(oldStereoMode);
|
|
}
|
|
else
|
|
{
|
|
// simple render
|
|
rrc->Render( (CK_RENDER_FLAGS)ropt );
|
|
}
|
|
}
|
|
if( rtview.tex && updateSystem )
|
|
{
|
|
int oldSlot = rtview.tex->GetCurrentSlot();
|
|
if (stereo)
|
|
{
|
|
// Nicov : force use of slot 0 (slot 0 <- left, slot 1 <- right)
|
|
rtview.tex->SetCurrentSlot(0);
|
|
}
|
|
rtview.tex->VideoToSystemMemory();
|
|
if (stereo)
|
|
{
|
|
rtview.tex->SetCurrentSlot(oldSlot);
|
|
}
|
|
}
|
|
if (updateSystem && rightEyeRendered)
|
|
{
|
|
if (leftEye->GetWidth() > 0 && leftEye->GetHeight() > 0)
|
|
{
|
|
XASSERT(rightEye);
|
|
if (leftEye->GetSlotCount() < 2)
|
|
{
|
|
leftEye->SetSlotCount(2);
|
|
leftEye->CreateImage(leftEye->GetWidth(), leftEye->GetHeight(), 32, 1, NULL);
|
|
}
|
|
leftEye->VideoToSlotSystemMemory(*rightEye, 1);
|
|
}
|
|
}
|
|
if (countPixels)
|
|
{
|
|
pixelCount = AddSat(pixelCount, rc->GetRasterizerContext()->WaitOcclusionQueryResult());
|
|
}
|
|
}
|
|
rc->SetCurrentRenderOptions(oldRopt);
|
|
|
|
//--- Restore stuff
|
|
if(overrideTechnique || overidingMaterial)
|
|
{
|
|
rc->SetOverriddenRendering( CK_OVERRIDE_NONE );
|
|
}
|
|
|
|
if( oldCam ) rc->AttachViewpointToCamera( oldCam );
|
|
CKDWORD version = beh->GetVersion();
|
|
if (version >= 0x00020000)
|
|
rc->SetViewTransformationMatrix(oldViewMat);
|
|
rc->ForceCameraSettingsUpdate();
|
|
|
|
bgMat->SetDiffuse( oldBgColor );
|
|
bgMat->SetTexture( oldBgTex );
|
|
|
|
if (rtview.tex)
|
|
{
|
|
rc->SetRenderTarget( NULL );
|
|
|
|
if(currentRTCount>1){
|
|
int rtIndex = 0;
|
|
/*
|
|
for(int i=1;i<currentRTCount;i++){
|
|
rc->SetRenderTarget(NULL,i);
|
|
}
|
|
*/
|
|
for(int i=currentRTCount - 1;i>= 1;i--){
|
|
rc->SetRenderTarget(NULL,i);
|
|
}
|
|
}
|
|
rc->SetViewRect( oldRect );
|
|
}
|
|
|
|
// TMP TMP
|
|
// For next version only
|
|
//beh->SetOutputParameterValue(PARAM_PIXELCOUNT, &pixelCount);
|
|
|
|
return CKBR_OK;
|
|
}
|
|
|
|
/*************************************************************************/
|
|
// Call Back
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
CKERROR RenderSceneCallback(const CKBehaviorContext& behcontext)
|
|
{
|
|
CKBehavior* beh = behcontext.Behavior;
|
|
|
|
switch( behcontext.CallbackMessage ){
|
|
|
|
|
|
case CKM_BEHAVIORLOAD:
|
|
{
|
|
// TMP TMP : for next version
|
|
/*
|
|
if(!beh->GetOutputParameter(PARAM_PIXELCOUNT))
|
|
{
|
|
beh->CreateOutputParameter("Pixel count", PARAM_PIXELCOUNT);
|
|
int pixelCount = 0;
|
|
beh->SetOutputParameterValue(PARAM_PIXELCOUNT, &pixelCount);
|
|
}
|
|
*/
|
|
if(beh->GetOutputParameter(PARAM_PIXELCOUNT))
|
|
{
|
|
// remove for safety, until next version
|
|
beh->EnableOutputParameter(PARAM_PIXELCOUNT, FALSE);
|
|
}
|
|
|
|
|
|
// TMP TMP : for next version
|
|
/*
|
|
if(!beh->GetLocalParameter(PARAM_COUNT_PIXELS_USING_OCCLUSION_QUERY))
|
|
{
|
|
beh->CreateLocalParameter("Count pixels using occlusion query", CKPGUID_BOOL);
|
|
CKBOOL disabled = FALSE;
|
|
beh->SetLocalParameterValue(PARAM_COUNT_PIXELS_USING_OCCLUSION_QUERY, &disabled);
|
|
}
|
|
*/
|
|
|
|
if(!beh->GetInputParameter(PARAM_BGTEXTURE))
|
|
{
|
|
beh->CreateInputParameter("Background Texture", CKPGUID_TEXTURE);
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_CAMERA))
|
|
{
|
|
beh->CreateInputParameter("Camera", CKPGUID_CAMERA);
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_FACEBYFACE))
|
|
{
|
|
beh->CreateInputParameter("(CubeMap) Render Face by Face", CKPGUID_BOOL);
|
|
/*BOOL vFalse = FALSE;
|
|
beh->SetInputParameterValue(PARAM_FACEBYFACE, &vFalse);*/
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_UPDATESYSTEMMEMORY))
|
|
{
|
|
beh->CreateInputParameter("Update System Memory", CKPGUID_BOOL);
|
|
/*BOOL vFalse = FALSE;
|
|
beh->SetInputParameterValue(PARAM_UPDATESYSTEMMEMORY, &vFalse);*/
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_OVERIDINGMATERIAL))
|
|
{
|
|
beh->CreateInputParameter("Overiding Material", CKPGUID_MATERIAL);
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_ORIENTATIONREFERENTIAL))
|
|
{
|
|
beh->CreateInputParameter("Orientation Referential", CKPGUID_3DENTITY);
|
|
}
|
|
|
|
|
|
if(!beh->GetLocalParameter(PARAM_HOMOGENEOUSVIEW))
|
|
{
|
|
beh->CreateLocalParameter("Viewport is Homogeneous", CKPGUID_BOOL);
|
|
}
|
|
else
|
|
{
|
|
// old version : first setting was false
|
|
if (strcmp(beh->GetLocalParameter(PARAM_HOMOGENEOUSVIEW)->GetName(), "Render Target Count") == 0)
|
|
{
|
|
CKParameterManager* pMgr = behcontext.Context->GetParameterManager();
|
|
if (pMgr)
|
|
{
|
|
beh->GetLocalParameter(PARAM_HOMOGENEOUSVIEW)->SetName("Viewport is Homogeneous");
|
|
beh->GetLocalParameter(PARAM_HOMOGENEOUSVIEW)->SetType(pMgr->ParameterGuidToType(CKPGUID_BOOL));
|
|
CKBOOL vFalse = FALSE;
|
|
beh->GetLocalParameter(PARAM_HOMOGENEOUSVIEW)->SetValue(&vFalse);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!beh->GetLocalParameter(PARAM_RTCOUNT))
|
|
{
|
|
beh->CreateLocalParameter("Render Target Count",CKPGUID_INT);
|
|
int one = 1;
|
|
beh->SetLocalParameterValue(PARAM_RTCOUNT,&one);
|
|
}
|
|
|
|
|
|
if(!beh->GetInputParameter(PARAM_OVERRIDETECHNIQUE))
|
|
{
|
|
beh->CreateInputParameter("Override Shader Technique",CKPGUID_BOOL);
|
|
//CKBOOL value = FALSE;
|
|
//beh->SetLocalParameterValue(PARAM_RTCOUNT, &value);
|
|
}
|
|
|
|
if(!beh->GetInputParameter(PARAM_TECHNIQUENAME))
|
|
{
|
|
beh->CreateInputParameter("Override Technique Name",CKPGUID_STRING);
|
|
}
|
|
|
|
} break;
|
|
|
|
case CKM_BEHAVIORSETTINGSEDITED:
|
|
{
|
|
//--- Get Wanted View Count
|
|
int wantedRTCount = 1;
|
|
beh->GetLocalParameterValue( PARAM_RTCOUNT, &wantedRTCount );
|
|
|
|
//--- Get Previous View Count
|
|
int currentRTCount = GetCurrentRTCount( beh );
|
|
|
|
if( currentRTCount != wantedRTCount ){
|
|
|
|
//--- Limit View Count
|
|
if( wantedRTCount<1 ) wantedRTCount = 1;
|
|
if( wantedRTCount>MAXRT_COUNT ) wantedRTCount = MAXRT_COUNT;
|
|
|
|
beh->SetLocalParameterValue( PARAM_RTCOUNT, &wantedRTCount );
|
|
|
|
//--- Destroy pIns beyond "View Current"
|
|
for(int i=1;i<MAXRT_COUNT;){
|
|
CKParameterIn* pin = beh->GetInputParameter(i);
|
|
if(pin->GetGUID() == CKPGUID_TEXTURE)
|
|
if(i>=wantedRTCount)
|
|
CKDestroyObject( beh->RemoveInputParameter(i) );
|
|
else
|
|
i++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
//--- Create missing view pIns
|
|
char pInName[8];
|
|
for( int a=currentRTCount ; a<wantedRTCount ; ++a ){
|
|
sprintf( pInName, "RT %d", a );
|
|
beh->InsertInputParameter(PARAM_VIEW+a,behcontext.Context->CreateCKParameterIn(pInName, CKPGUID_TEXTURE));
|
|
}
|
|
}
|
|
|
|
} break;
|
|
}
|
|
return CKBR_OK;
|
|
}
|
|
|
|
|
|
|
|
/***********************************************/
|
|
// PROTO
|
|
/***********************************************/
|
|
CKERROR CreateRenderSceneProto(CKBehaviorPrototype **pproto)
|
|
{
|
|
CKBehaviorPrototype *proto = CreateCKBehaviorPrototype("Render Scene In RT View");
|
|
if(!proto) return CKERR_OUTOFMEMORY;
|
|
|
|
proto->DeclareInput("In");
|
|
proto->DeclareOutput("Out");
|
|
|
|
proto->DeclareInParameter("Target View", CKPGUID_RTVIEW);
|
|
proto->DeclareInParameter("Render Options", CKPGUID_RENDEROPTIONS, "Background Sprites,Clear ZBuffer,Clear Stencil Buffer,Clear Back Buffer");
|
|
proto->DeclareInParameter("Background Color", CKPGUID_COLOR);
|
|
proto->DeclareInParameter("Background Texture", CKPGUID_TEXTURE);
|
|
proto->DeclareInParameter("Camera", CKPGUID_CAMERA );
|
|
proto->DeclareInParameter("(CubeMap) Render Face by Face",CKPGUID_BOOL,"FALSE");
|
|
proto->DeclareInParameter("Update System Memory",CKPGUID_BOOL,"FALSE");
|
|
proto->DeclareInParameter("Overiding Material",CKPGUID_MATERIAL);
|
|
proto->DeclareInParameter("Orientation Referential",CKPGUID_3DENTITY);
|
|
proto->DeclareInParameter("Override Shader Technique",CKPGUID_BOOL);
|
|
proto->DeclareInParameter("Override Technique Name",CKPGUID_STRING);
|
|
|
|
// TMP : for next version only
|
|
// proto->DeclareOutParameter("Pixel count", CKPGUID_INT, "0");
|
|
|
|
proto->DeclareSetting("Viewport is Homogeneous",CKPGUID_BOOL, "FALSE");
|
|
proto->DeclareSetting("Render Target Count",CKPGUID_INT, "1");
|
|
// TMP : for next version only
|
|
//proto->DeclareSetting("Count pixels using occlusion query", CKPGUID_BOOL, "FALSE");
|
|
|
|
proto->SetFlags(CK_BEHAVIORPROTOTYPE_NORMAL);
|
|
proto->SetFunction(RenderScene);
|
|
|
|
proto->SetBehaviorCallbackFct( RenderSceneCallback,CKCB_BEHAVIORLOAD | CKCB_BEHAVIORSETTINGSEDITED);
|
|
|
|
*pproto = proto;
|
|
return CK_OK;
|
|
}
|
|
|
|
/***********************************************/
|
|
// DECLARATION
|
|
/***********************************************/
|
|
CKObjectDeclaration *FillBehaviorRenderScene()
|
|
{
|
|
CKObjectDeclaration *od = CreateCKObjectDeclaration("Render Scene In RT View");
|
|
od->SetDescription("Renders the scene into a RenderTarget View");
|
|
od->SetCategory("Shaders/Rendering");
|
|
od->SetType(CKDLL_BEHAVIORPROTOTYPE);
|
|
od->SetGuid(RENDERSCENE_GUID);
|
|
od->SetAuthorGuid(VIRTOOLS_GUID);
|
|
od->SetAuthorName("Virtools");
|
|
od->SetVersion(0x00020000);
|
|
od->SetCreationFunction(CreateRenderSceneProto);
|
|
od->SetCompatibleClassId(CKCID_BEOBJECT);
|
|
return od;
|
|
}
|