void
COpenGLDemo::RenderScene()
{
PreRender();
Render();
PostRender();
}
void CCylinder::drawGLScene()
{
PreRender();
glPushMatrix();
glTranslatef(m_locationX,
m_locationY,
m_locationZ);
glMultMatrixf(m_rotation);
glTranslatef(0.0,0.0,(float)(-m_sizeZ/2.0));
glScalef(m_sizeX, m_sizeY, m_sizeZ);
glColor3f(m_colourRed,
m_colourGreen,
m_colourBlue);
//if ( touching() )
//{
// glColor3f(0,
// 1,
// 0);
//}
int stacks= ((CProtoHapticApp*)AfxGetApp())->getStacks();
gluCylinder(s, 0.5*m_ratio,0.5,1, stacks, stacks);
gluDisk(d1,0.0,0.5*m_ratio,stacks,stacks);
glTranslated(0.0,0.0,1);
gluDisk(d2,0.0,0.5,stacks,stacks);
glPopMatrix();
}
void SpriteWrapper::Render(Vector2<int> aPosition)
{
if(mySprite!=NULL)
{
PreRender();
mySprite->Render(static_cast<float>(aPosition.myX), static_cast<float>(aPosition.myY));
}
}
bool KCore::GameRender()
{
PreRender();
Render();
m_Timer.Render();
I_Input.Render();
DrawDebug();
PostRender();
return true;
}
void CScythe::RenderScythe( void )
{
if( m_pTex )
{
PreRender( );
DrawScythe( );
PostRender( );
}
}
void CShockWaveEffect::Render()
{
if(!PreRender())
{
return;
}
if (GetOwner() != NULL)
{ // HIDDEN 속성의 NPC의 이펙트를 보기 위해서는 캐릭터가 ENF_SHOWHIDDEN을 가지고 있어야 한다.
if (GetOwner()->IsFlagOn(ENF_HIDDEN) && (CEntity::GetPlayerEntity(0)->IsFlagOff(ENF_SHOWHIDDEN) ||
(CEntity::GetPlayerEntity(0)->IsFlagOn(ENF_SHOWHIDDEN)&&!GetOwner()->IsEnemy())))//ENF_SHOWHIDDEN이면 npc effect는 볼 수 있다.
return;
}
gfxSetBlendType(m_eBlendType);
if(m_ptdTexture != NULL)
{
gfxSetTextureUnit(0);
m_ptdTexture->SetAsCurrent();
if(RM_AreHardwareShadersAvailable())
{
gfxSetVertexProgram( m_ulVertexProgramTex );
gfxSetPixelProgram( m_ulPixelProgramTex );
}
else
{
gfxSetTextureModulation(1);
}
}
else
{
if(RM_AreHardwareShadersAvailable())
{
gfxSetVertexProgram( m_ulVertexProgramNoTex );
gfxSetPixelProgram( m_ulPixelProgramNoTex );
}
else
{
//gfxSetTextureSelectArg(0, GFX_TA_DIFFUSE, GFX_TA_DIFFUSE);
}
}
gfxSetVertexArray( &m_vectorGFXVertex[0], m_vectorGFXVertex.size() );
gfxSetColorArray( &m_vectorGFXColor[0] );
if(m_ptdTexture != NULL) gfxSetTexCoordArray( &m_vectorTexCoord[0], FALSE );
gfxDrawElements( m_iSplitCount * 2 * 3, &m_vectorIndex[0]);
if(!RM_AreHardwareShadersAvailable())
{
//gfxSetTextureSelectArg(0, GFX_TA_TEXTURE, GFX_TA_TEXTURE);
gfxSetTextureModulation(1);
}
PostRender();
}
bool CParticleSystem::RenderSystem( void )
{
// heres where we loop through the system and render it
if( TestSystem( ) )
{
// if test works update it
UpdateSystem( );
//now we loop thorugh the parts in the system and render them
Particle_s *pPart = m_pHeadPart;
int iCount = 0;
PreRender( );
while( pPart )
{
// first we need to test if the particle should still be living
Particle_s *pTmp = pPart->pNext;
if( TestPart( pPart ) )
{
UpdatePart( pPart );
if( TestVisability( pPart ) )
{
// then we should update the particle
// now draw it
RenderPart( pPart );
iCount ++;
}
}
else
{
// test show no need for particle remove it
ReturnToPool( pPart );
}
//move to the next part
pPart = pTmp;
}
// turn it off
PostRender( );
// if( iCount >= 5000 )
/*{
gEngfuncs.Con_Printf( "Parts: %i\n", iCount );
}*/
}
else
{
//we can break out system doesnt need to be around any more
return false;
}
//every thing was successfull
return true;
}
DllExport
PF_Err
EntryPointFunc (
PF_Cmd cmd,
PF_InData *in_data,
PF_OutData *out_data,
PF_ParamDef *params[],
PF_LayerDef *output,
void *extra)
{
PF_Err err = PF_Err_NONE;
try {
switch (cmd) {
case PF_Cmd_ABOUT:
err = About(in_data, out_data, params, output);
break;
case PF_Cmd_GLOBAL_SETUP:
err = GlobalSetup( in_data, out_data, params, output);
break;
case PF_Cmd_PARAMS_SETUP:
err = ParamsSetup( in_data, out_data, params, output);
break;
case PF_Cmd_RENDER:
err = Render( in_data, out_data, params, output);
break;
case PF_Cmd_EVENT:
err = HandleEvent( in_data, out_data, params, output, reinterpret_cast<PF_EventExtra*>(extra));
break;
case PF_Cmd_ARBITRARY_CALLBACK:
err = HandleArbitrary( in_data, out_data, params, output, reinterpret_cast<PF_ArbParamsExtra*>(extra));
break;
case PF_Cmd_SMART_PRE_RENDER:
err = PreRender(in_data, out_data, reinterpret_cast<PF_PreRenderExtra*>(extra));
break;
case PF_Cmd_SMART_RENDER:
err = SmartRender( in_data, out_data, reinterpret_cast<PF_SmartRenderExtra*>(extra));
break;
}
} catch (PF_Err &thrown_err) {
err = thrown_err;
}
return err;
}
void pl3DPipeline::Draw(plDrawable* d)
{
plDrawableSpans *ds = plDrawableSpans::ConvertNoRef(d);
if (ds)
{
if (( ds->GetType() & fView.GetDrawableTypeMask()) == 0)
return;
static hsTArray<int16_t>visList;
PreRender(ds, visList);
PrepForRender(ds, visList);
Render(ds, visList);
}
}
bool scene::RenderFunc(float d)
{
PreRender(d);
OBJ_LSIT_ITR itr = m_obj_list.begin();
for (; itr != m_obj_list.end();itr++)
{
(*itr)->RenderFunc(d);
}
GUIAPP_LSIT_ITR itr_gui = m_guiapp_list.begin();
for (; itr_gui != m_guiapp_list.end();itr_gui++)
{
(*itr_gui)->RenderFunc(d);
}
PostRender(d);
return TRUE;
}
void EFFECT_FIREBALL::Render()
{
PreRender();
if(billboardMesh)
{
D3DXVECTOR3 orgRot = m_t1.m_rot;
D3DXVECTOR3 rotations[] = {D3DXVECTOR3(0.0f, 0.0f, 0.0f),
D3DXVECTOR3(D3DX_PI * 0.5f, 0.0f, 0.0f),
D3DXVECTOR3(0.0f, D3DX_PI * 0.5f, 0.0f),
D3DXVECTOR3(0.0f, 0.0f, D3DX_PI * 0.5f)};
D3DXVECTOR3 orgPos = m_t1.m_pos;
D3DXVECTOR3 positions[] = {m_t1.m_pos,
GetPosition(m_prc - (1.5f / m_length)),
GetPosition(m_prc - (2.5f / m_length)),
GetPosition(m_prc - (3.25f / m_length)),
GetPosition(m_prc - (4.0f / m_length))};
D3DXVECTOR3 orgSca = m_t1.m_sca;
D3DXVECTOR3 scales[] = {m_t1.m_sca,
m_t1.m_sca * 0.8f,
m_t1.m_sca * 0.6f,
m_t1.m_sca * 0.4f,
m_t1.m_sca * 0.2f};
m_pDevice->SetTexture(0, fireballTexture);
for(int t=0;t<5;t++)
for(int i=0;i<4;i++)
{
m_t1.m_pos = positions[t];
m_t1.m_rot = orgRot + rotations[i];
m_t1.m_sca = scales[t];
effectVertexShader.SetMatrix(effectMatW, m_t1.GetWorldMatrix());
billboardMesh->DrawSubset(0);
}
m_t1.m_pos = orgPos;
m_t1.m_rot = orgRot;
m_t1.m_sca = orgSca;
}
PostRender();
}
//----------------------------------------------------------------------------
void AllegroRender::Render() {
// Pre-Render
PreRender();
// Clear screen
al_clear_to_color(al_map_rgb_f(0, 0, 0));
// Render
sceneManager->Render();
// TODO: remove me...
//al_draw_text(font, al_map_rgba_f(1, 1, 1, 0.5), 0, 0, 0, text);
// Display frame
FlipDoubleBuffer();
// Post Render
PostRender();
}
inline FTPoint FTTextureFontImpl::RenderI(const T* string, const int len,
FTPoint position, FTPoint spacing,
int renderMode)
{
disableTexture2D = false;
disableBlend = false;
FTPoint tmp;
if (preRendered)
{
tmp = FTFontImpl::Render(string, len, position, spacing, renderMode);
}
else
{
PreRender();
tmp = FTFontImpl::Render(string, len, position, spacing, renderMode);
PostRender();
}
return tmp;
}
void EFFECT_SPELL::Render()
{
PreRender();
if(billboardMesh)
{
//Spinning quad
m_pDevice->SetTexture(0, runesTexture);
effectVertexShader.SetMatrix(effectMatW, m_t1.GetWorldMatrix());
billboardMesh->DrawSubset(0);
//Cloud
m_pDevice->SetTexture(0, cloudTexture);
for(int i=0;i<10;i++)
{
effectVertexShader.SetMatrix(effectMatW, m_c[i].GetWorldMatrix());
billboardMesh->DrawSubset(0);
}
}
PostRender();
}
//protected:
virtual void Render() const override {
//Debug::Log("Rendere %s", m_gameObject->name().c_str());
auto meshFilter = m_gameObject->GetComponent<MeshFilter>();
if (meshFilter == nullptr) {
Debug::LogWarning("This GameObject has no MeshFilter");
return;
}
auto model = transform()->localToWorldMatrix();
auto camera = Scene::mainCamera();
auto view = camera->worldToCameraMatrix();
auto proj = camera->projectionMatrix();
auto mv = view * model;
auto mvp = proj * mv;
ShaderUniforms uniforms;
//std::map<std::string, Matrix4x4> matrices;
uniforms.mat4s["_Object2World"] = model;
uniforms.mat4s["MATRIX_V"] = view;
uniforms.mat4s["MATRIX_P"] = proj;
uniforms.mat4s["MATRIX_VP"] = proj * view;
uniforms.mat4s["MATRIX_MVP"] = mvp;
uniforms.mat4s["MATRIX_MV"] = mv;
uniforms.mat4s["MATRIX_IT_M"] = glm::inverse(glm::transpose(model));
uniforms.mat4s["MATRIX_IT_MV"] = glm::inverse(glm::transpose(mv));
//auto camera = Scene::getMainCamera();
uniforms.vec3s["_WorldSpaceCameraPos"] = camera->transform()->position();
for (auto& m : m_materials) {
auto shader = m->shader();
shader->Use();
shader->PreRender();
shader->BindUniforms(uniforms);
m->Update();
shader->CheckStatus();
meshFilter->mesh()->Render();
shader->PostRender();
}
}
void CTorus::drawGLScene()
{
PreRender();
glPushMatrix();
glTranslatef(m_locationX,
m_locationY,
m_locationZ);
glMultMatrixf(m_rotation);
glScalef(m_sizeX, m_sizeY, m_sizeZ );
glColor3f(m_colourRed,
m_colourGreen,
m_colourBlue);
int stacks= ((CProtoHapticApp*)AfxGetApp())->getStacks();
doughnut ( m_radiusMinor, m_radiusMajor, stacks, stacks, m_drawnFraction );
glPopMatrix();
}
void idRenderWindow::Draw(int time, float x, float y) {
PreRender();
Render(time);
memset( &refdef, 0, sizeof( refdef ) );
refdef.vieworg = viewOffset.ToVec3();;
//refdef.vieworg.Set(-128, 0, 0);
refdef.viewaxis.Identity();
refdef.shaderParms[0] = 1;
refdef.shaderParms[1] = 1;
refdef.shaderParms[2] = 1;
refdef.shaderParms[3] = 1;
refdef.x = drawRect.x;
refdef.y = drawRect.y;
refdef.width = drawRect.w;
refdef.height = drawRect.h;
refdef.fov_x = 90;
refdef.fov_y = 2 * atan((float)drawRect.h / drawRect.w) * idMath::M_RAD2DEG;
refdef.time = time;
world->RenderScene(&refdef);
}
bool CLightningFX::Update(float tmFrameTime)
{
// Base class update first
if (!CBaseFX::Update(tmFrameTime))
return false;
if( !IsShuttingDown() )
{
EmitBolts( tmFrameTime );
}
// Check to see if any bolts have expired...
CLightningBolt *pBolt = LTNULL;
LightningBolts::iterator iter;
for( iter = m_lstBolts.begin(); iter != m_lstBolts.end(); ++iter )
{
pBolt = *iter;
//adjust our start time
pBolt->m_tmElapsed += tmFrameTime;
if( pBolt->m_fLifetime < pBolt->m_tmElapsed )
pBolt->m_bActive = false;
}
// Setup the bolts for rendering
PreRender( tmFrameTime );
// Success !!
return true;
}
void SpriteWrapper::Render(Vector2<float> aPosition, const float aRotation, const float anXScale, const float anYScale)
{
PreRender();
mySprite->RenderEx(aPosition.myX, aPosition.myY, aRotation, anXScale, anYScale);
}
bool GBoneObj::Render(ID3D11DeviceContext* pContext)
{
PreRender(pContext);
Draw(pContext, this);
return true;
}
bool RenderThread::Run()
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run\n");
// Install a function for logging
mEnvironmentOptions.InstallLogFunction();
InitializeEgl();
Dali::Integration::RenderStatus renderStatus;
RenderRequest* request = NULL;
// Render loop, we stay inside here when rendering
while( mThreadSynchronization.RenderReady( request ) )
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 1 - RenderReady\n");
// Consume any pending events to avoid memory leaks
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 2 - ConsumeEvents\n");
mDisplayConnection->ConsumeEvents();
// Check if we've got a request from the main thread (e.g. replace surface)
if( request )
{
// Process the request, we should NOT render when we have a request
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Process requests\n");
ProcessRequest( request );
}
else
{
// No request to process so we render
if( PreRender() ) // Returns false if no surface onto which to render
{
// Render
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 3 - Core.Render()\n");
mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_START );
mCore.Render( renderStatus );
mThreadSynchronization.AddPerformanceMarker( PerformanceInterface::RENDER_END );
// Decrement the count of how far update is ahead of render
mThreadSynchronization.RenderFinished();
// Perform any post-render operations
if ( renderStatus.HasRendered() )
{
DALI_LOG_INFO( gRenderLogFilter, Debug::Verbose, "RenderThread::Run. 4 - PostRender()\n");
PostRender();
}
}
}
request = NULL; // Clear the request if it was set, no need to release memory
}
// Shut down EGL
ShutdownEgl();
// Uninstall the logging function
mEnvironmentOptions.UnInstallLogFunction();
return true;
}
HRESULT KGraphicsEngine::InitializeWindowed(HWND hBaseWindow, HWND hRenderWindow)
{
// Create the D3D object.
if ( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )
{
MessageBox(hBaseWindow,"Failed Create the D3D object!.","Failed Create the D3D object!",0);
return E_FAIL;
}
// Get the current desktop display mode, so we can set up a back
// buffer of the same format
g_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,&g_D3DCaps);
if ( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &m_DisplayMode ) ) )
{
MessageBox(hBaseWindow,"Failed GetAdapterDisplayMode !.","Failed Create the D3D object!",0);
return E_FAIL;
}
// Set up the structure used to create the D3DDevice
D3DFORMAT DepFormat;
if (SUCCEEDED(g_pD3D->CheckDepthStencilMatch(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
m_DisplayMode.Format,
m_DisplayMode.Format,
D3DFMT_D24S8)))
{
DepFormat = D3DFMT_D24S8;
}
else
{
DepFormat = D3DFMT_D16;
}
memset( &m_PresentParam, 0, sizeof(D3DPRESENT_PARAMETERS) );
memset(&m_RenderWindowRect, 0, sizeof(m_RenderWindowRect));
if(hRenderWindow)
::GetWindowRect(hRenderWindow,&m_RenderWindowRect);
else
{
::GetWindowRect(hBaseWindow,&m_RenderWindowRect);
hRenderWindow = hBaseWindow;
}
//m_PresentParam.BackBufferWidth = m_RenderWindowRect.right-m_RenderWindowRect.left ;
//m_PresentParam.BackBufferHeight= m_RenderWindowRect.bottom - m_RenderWindowRect.top;
m_PresentParam.BackBufferWidth = m_DisplayMode.Width ;
m_PresentParam.BackBufferHeight= m_DisplayMode.Height;
m_PresentParam.Windowed = TRUE ;
m_PresentParam.SwapEffect = D3DSWAPEFFECT_DISCARD;
m_PresentParam.BackBufferFormat = m_DisplayMode.Format;
m_PresentParam.EnableAutoDepthStencil = TRUE;
m_PresentParam.AutoDepthStencilFormat = DepFormat;
m_PresentParam.MultiSampleType = D3DMULTISAMPLE_NONE;
m_PresentParam.hDeviceWindow = hBaseWindow;
m_PresentParam.Flags = 0;
m_PresentParam.FullScreen_RefreshRateInHz = 0;
m_PresentParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
//just set camera's aspect
m_cCamera.Aspect = m_PresentParam.BackBufferWidth*1.0f/m_PresentParam.BackBufferHeight;
HRESULT hr;
// Set default settings
UINT AdapterToUse=D3DADAPTER_DEFAULT;
D3DDEVTYPE DeviceType=D3DDEVTYPE_HAL;
//#if SHIPPING_VERSION
// When building a shipping version, disable NVPerfHUD (opt-out)
//#else
// Look for 'NVIDIA NVPerfHUD' adapter
// If it is present, override default settings
for (UINT Adapter=0;Adapter<g_pD3D->GetAdapterCount();Adapter++)
{
D3DADAPTER_IDENTIFIER9 Identifier;
HRESULT Res=g_pD3D->GetAdapterIdentifier(Adapter,0,&Identifier);
if (strcmp(Identifier.Description,"NVIDIA NVPerfHUD")==0)
{
AdapterToUse=Adapter;
DeviceType=D3DDEVTYPE_REF;
break;
}
}
//#endif
// Create the D3DDevice
/*if ( FAILED(hr = g_pD3D->CreateDevice( AdapterToUse, DeviceType, hBaseWindow,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&m_PresentParam, &g_pd3dDevice ) ) )
{*/
if ( FAILED(hr = g_pD3D->CreateDevice( AdapterToUse, DeviceType, hBaseWindow,
D3DCREATE_MIXED_VERTEXPROCESSING,
&m_PresentParam, &g_pd3dDevice ) ) )
{
if ( FAILED(hr = g_pD3D->CreateDevice( AdapterToUse, DeviceType, hBaseWindow,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&m_PresentParam, &g_pd3dDevice ) ) )
{
if (hr == D3DERR_INVALIDCALL)
MessageBox(hBaseWindow,"The method call is invalid. For example, a method's parameter may have an invalid value.","Failed Create Device!",0);
else if (hr == E_OUTOFMEMORY )
MessageBox(hBaseWindow,"Direct3D could not allocate sufficient memory to complete the call.","Failed Create Device!",0);
else if (hr == D3DERR_OUTOFVIDEOMEMORY)
MessageBox(hBaseWindow,"Direct3D does not have enough display memory to perform the operation. ","Failed Create Device!",0);
return E_FAIL;
}
}
/* }*/
// D3DMULTISAMPLE_TYPE Mul = D3DMULTISAMPLE_4_SAMPLES;
//
// if( FAILED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.BackBufferFormat,
// FALSE, Mul, NULL ) ) &&
// SUCCEEDED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.AutoDepthStencilFormat,
// FALSE, Mul, NULL ) ) )
// {
// Mul = D3DMULTISAMPLE_3_SAMPLES;
//
// if( FAILED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.BackBufferFormat,
// FALSE, Mul, NULL ) ) &&
// SUCCEEDED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.AutoDepthStencilFormat,
// FALSE, Mul, NULL ) ) )
// {
// Mul = D3DMULTISAMPLE_2_SAMPLES;
//
// if( FAILED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.BackBufferFormat,
// FALSE, Mul, NULL ) ) &&
// SUCCEEDED(g_pD3D->CheckDeviceMultiSampleType( D3DADAPTER_DEFAULT,
// D3DDEVTYPE_HAL, m_PresentParam.AutoDepthStencilFormat,
// FALSE, Mul, NULL ) ) )
// {
// Mul = D3DMULTISAMPLE_NONE;
// }
// }
// }
// if (Mul != D3DMULTISAMPLE_NONE)
// {
// m_PresentParam.MultiSampleType = Mul;
// g_pd3dDevice->Reset( &m_PresentParam );
// }
// Device state would normally be set here
// Turn off culling, so we see the front and back of the triangle
g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
// Turn off D3D lighting, since we are providing our own vertex colors
// Turn on the zbuffer
g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
//g_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
g_pd3dDevice->SetRenderState( D3DRS_ZFUNC, D3DCMP_LESSEQUAL );
g_cGraphicsTool.SetCurCamera(&m_cCamera);
PreRender();
m_bWindowed = TRUE;
if (m_bUseMotionBlur)
{
BackBufferCreate();
g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL,
0xff666666, 1.0f, 0 );
}
return S_OK;
}
void SpriteWrapper::Render(Vector2<float> aPosition)
{
PreRender();
mySprite->Render(aPosition.myX, aPosition.myY);
}
bool TDxObject::Render(ID3D11DeviceContext* pContext, UINT iVertexSize, UINT iCount)
{
PreRender(pContext, iVertexSize);
PostRender(pContext, iCount);
return true;
}
//Draw each piece to the DC
void SplitImage4::Render(wxDC* dc, const int &w, const int &h, const int& x, const int& y, const bool& center){
#ifdef SPLIT_IMAGE_DEBUG
linen=0;
#endif
// Prepping variables
int edge, ox, oy, width, height;
int widthl = 0, widthr = 0, heightt = 0, heightb = 0;
// if the size of the render is less than the splitimage's minsize
bool underw = w < MinSize.GetWidth();
bool underh = h < MinSize.GetHeight();
//if undersized figure out the sizes based on ratio
if (underw)
{
widthl = (int)((float)w * (float)ratio[0]);
widthr = (int)((float)w * (float)ratio[1]);
if ( w-(widthl+widthr) )widthr += (w-(widthl+widthr));
}
if (underh)
{
heightt = (int)((float)h * (float)ratio[2]);
heightb = (int)((float)h * (float)ratio[3]);
if ( h-(heightt+heightb) )heightb += (h-(heightt+heightb));
}
// create a memory DC for the blits
wxMemoryDC pmdc;
// create an array of pointers to the coreners for iterating
wxImage* c[] = {splitimage.c1, splitimage.c2, splitimage.c3, splitimage.c4};
// stamp each corner in place if it exists
for (int i=0; i < 4; ++i)
{
if (c[i])
{
width = underw? (i==0||i==2? widthl:widthr) : (c[i]->GetWidth());
height = underh? (i==0||i==1? heightt:heightb) : (c[i]->GetHeight());
ox = i == 0 || i == 2 ? 0 : w - width;
oy = i < 2 ? 0 : h - height;
if (width < 1 || height < 1)
continue;
//dc->DrawBitmap(wxBitmap(c[i]->Scale(width,height)),ox+x,oy+y,true);
wxBitmap bmp = wxBitmap(c[i]->Scale(width,height));
pmdc.SelectObject(bmp);
dc->Blit(ox+x,oy+y,width,height,&pmdc,0,0, wxCOPY, true);
}
}
//calculate the position and size of each edge and the center then prerender and stamp in place
int rwidth = 0, bheight = 0;
if(splitimage.top/* && !underw*/)
{
edge= splitimage.c2? w-splitimage.c2->GetWidth() : w;
width= edge-splitimage.top->pos.x;
height= underh? heightt: max(1,splitimage.top->image.GetHeight());
PreRender(dc,*splitimage.top,splitimage.top->pos.x+x,splitimage.top->pos.y+y,width,height);
}
if(splitimage.bottom/* && !underw*/)
{
edge= splitimage.c4?w-splitimage.c4->GetWidth():w;
width= edge-splitimage.bottom->pos.x;
bheight = height= underh? heightb: splitimage.bottom->image.GetHeight();
PreRender(dc,*splitimage.bottom,splitimage.bottom->pos.x+x,h-height+y,width,height);
}
if(splitimage.left/* && !underh*/)
{
edge= splitimage.c3?h-splitimage.c3->GetHeight():h;
width= underw? widthl: splitimage.left->image.GetWidth();
height= edge-splitimage.left->pos.y;
PreRender(dc,*splitimage.left,splitimage.left->pos.x+x,splitimage.left->pos.y+y,width,height);
}
if(splitimage.right/* && !underh*/)
{
edge= splitimage.c4?h-splitimage.c4->GetHeight():h;
rwidth =width= underw? widthr: splitimage.right->image.GetWidth();
height= edge-splitimage.right->pos.y;
PreRender(dc,*splitimage.right,w-width+x,splitimage.right->pos.y+y,width,height);
}
if(splitimage.center && center)
{
width= splitimage.right?w-rwidth-splitimage.center->pos.x:w-splitimage.center->pos.x;
height= splitimage.bottom? h-bheight-splitimage.center->pos.y : h-splitimage.center->pos.y;
PreRender(dc,*splitimage.center,splitimage.center->pos.x+x,splitimage.center->pos.y+y,width,height);
}
//Release the bitmap in the memory DC
pmdc.SelectObject(wxNullBitmap);
}
LRESULT CALLBACK C3DCoordinateAxisMain::WndProc(HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
TCHAR log[256]= {0,};
//std::string info;
HDC hdc;
PAINTSTRUCT ps;
//POINT pt;
switch(iMsg)
{
case WM_TIMER:
Update();
return 0;
case WM_LBUTTONDOWN:
{
POINT pt = {LOWORD(lParam), HIWORD(lParam)};
if( m_clickCnt < CLICK_MAX )
{
m_clickVecPt[m_clickCnt].x = pt.x - WIN_WIDTH/2;
m_clickVecPt[m_clickCnt].y = WIN_HEIGHT/2 - pt.y;
m_clickVecPt[m_clickCnt].z = 0;
m_clickCnt++;
if(m_clickCnt == CLICK_MAX)
{
VECTOR tempVec[2];
for (UINT i = 0 ; i < m_clickCnt ; i++ )
{
D3DVecNormalize( &tempVec[i], &m_clickVecPt[i]);
}
//cos0
float cos = D3DVecDot( &tempVec[0], &tempVec[1] );
//각도로 변경
degree = acosf(cos)*180/PI;
//외적
D3DVecCross(&m_crossVec, &tempVec[0], &tempVec[1]);
D3DVecNormalize( &m_crossVec, &m_crossVec );
}
}
}
return 0;
case WM_RBUTTONDOWN:
if(m_clickCnt > 0)
{
m_clickCnt--;
}
return 0;
case WM_PAINT:
{
hdc = BeginPaint(hWnd,&ps);
PreRender(hdc);
Render(m_hMemDc);
PostRender(hdc);
EndPaint(hWnd,&ps);
}
return 0;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE:
PostQuitMessage(0);
UnregisterTimer();
break;
}
break;
case WM_DESTROY:
PostQuitMessage(0);
UnregisterTimer();
return 0;
}
return DefWindowProc(hWnd, iMsg, wParam, lParam);
}
