mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2025-03-13 22:22:05 +00:00
ImGuizmo integration hello world
This commit is contained in:
Robert Beckebans
parent
6f98740772
commit
2317b9779d
6 changed files with 3551 additions and 1 deletions
|
|
@ -300,6 +300,7 @@ public:
|
|||
virtual void PlayerGetAxis( idMat3& axis ) const;
|
||||
virtual void PlayerGetViewAngles( idAngles& angles ) const;
|
||||
virtual void PlayerGetEyePosition( idVec3& org ) const;
|
||||
virtual bool PlayerGetRenderView( renderView_t& rv ) const;
|
||||
|
||||
// In game map editing support.
|
||||
virtual const idDict* MapGetEntityDict( const char* name ) const;
|
||||
|
|
|
|||
|
|
@ -711,7 +711,7 @@ void idEditEntities::DisplayEntities()
|
|||
// RB: use renderer backend to display light properties
|
||||
if( ent->fl.selected )
|
||||
{
|
||||
drawArrows = true;
|
||||
//drawArrows = true;
|
||||
|
||||
idLight* light = static_cast<idLight*>( ent );
|
||||
|
||||
|
|
@ -1159,6 +1159,18 @@ void idGameEdit::PlayerGetEyePosition( idVec3& org ) const
|
|||
org = gameLocal.GetLocalPlayer()->GetEyePosition();
|
||||
}
|
||||
|
||||
// RB
|
||||
bool idGameEdit::PlayerGetRenderView( renderView_t& rv ) const
|
||||
{
|
||||
renderView_t* view = gameLocal.GetLocalPlayer()->GetRenderView();
|
||||
if( view )
|
||||
{
|
||||
rv = *view;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
#pragma hdrstop
|
||||
|
||||
#include "BFGimgui.h"
|
||||
#include "ImGuizmo.h"
|
||||
#include "renderer/RenderCommon.h"
|
||||
#include "renderer/RenderBackend.h"
|
||||
|
||||
|
|
@ -829,6 +830,8 @@ void NewFrame()
|
|||
|
||||
// Start the frame
|
||||
ImGui::NewFrame();
|
||||
ImGuizmo::BeginFrame();
|
||||
|
||||
g_haveNewFrame = true;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
3152
neo/imgui/ImGuizmo.cpp
Normal file
3152
neo/imgui/ImGuizmo.cpp
Normal file
File diff suppressed because it is too large
Load diff
290
neo/imgui/ImGuizmo.h
Normal file
290
neo/imgui/ImGuizmo.h
Normal file
|
|
@ -0,0 +1,290 @@
|
|||
// https://github.com/CedricGuillemet/ImGuizmo
|
||||
// v 1.89 WIP
|
||||
//
|
||||
// The MIT License(MIT)
|
||||
//
|
||||
// Copyright(c) 2021 Cedric Guillemet
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files(the "Software"), to deal
|
||||
// in the Software without restriction, including without limitation the rights
|
||||
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
|
||||
// copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions :
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all
|
||||
// copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
// SOFTWARE.
|
||||
//
|
||||
// -------------------------------------------------------------------------------------------
|
||||
// History :
|
||||
// 2019/11/03 View gizmo
|
||||
// 2016/09/11 Behind camera culling. Scaling Delta matrix not multiplied by source matrix scales. local/world rotation and translation fixed. Display message is incorrect (X: ... Y:...) in local mode.
|
||||
// 2016/09/09 Hatched negative axis. Snapping. Documentation update.
|
||||
// 2016/09/04 Axis switch and translation plan autohiding. Scale transform stability improved
|
||||
// 2016/09/01 Mogwai changed to Manipulate. Draw debug cube. Fixed inverted scale. Mixing scale and translation/rotation gives bad results.
|
||||
// 2016/08/31 First version
|
||||
//
|
||||
// -------------------------------------------------------------------------------------------
|
||||
// Future (no order):
|
||||
//
|
||||
// - Multi view
|
||||
// - display rotation/translation/scale infos in local/world space and not only local
|
||||
// - finish local/world matrix application
|
||||
// - OPERATION as bitmask
|
||||
//
|
||||
// -------------------------------------------------------------------------------------------
|
||||
// Example
|
||||
#if 0
|
||||
void EditTransform( const Camera& camera, matrix_t& matrix )
|
||||
{
|
||||
static ImGuizmo::OPERATION mCurrentGizmoOperation( ImGuizmo::ROTATE );
|
||||
static ImGuizmo::MODE mCurrentGizmoMode( ImGuizmo::WORLD );
|
||||
if( ImGui::IsKeyPressed( 90 ) )
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
|
||||
}
|
||||
if( ImGui::IsKeyPressed( 69 ) )
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::ROTATE;
|
||||
}
|
||||
if( ImGui::IsKeyPressed( 82 ) ) // r Key
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::SCALE;
|
||||
}
|
||||
if( ImGui::RadioButton( "Translate", mCurrentGizmoOperation == ImGuizmo::TRANSLATE ) )
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::TRANSLATE;
|
||||
}
|
||||
ImGui::SameLine();
|
||||
if( ImGui::RadioButton( "Rotate", mCurrentGizmoOperation == ImGuizmo::ROTATE ) )
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::ROTATE;
|
||||
}
|
||||
ImGui::SameLine();
|
||||
if( ImGui::RadioButton( "Scale", mCurrentGizmoOperation == ImGuizmo::SCALE ) )
|
||||
{
|
||||
mCurrentGizmoOperation = ImGuizmo::SCALE;
|
||||
}
|
||||
float matrixTranslation[3], matrixRotation[3], matrixScale[3];
|
||||
ImGuizmo::DecomposeMatrixToComponents( matrix.m16, matrixTranslation, matrixRotation, matrixScale );
|
||||
ImGui::InputFloat3( "Tr", matrixTranslation, 3 );
|
||||
ImGui::InputFloat3( "Rt", matrixRotation, 3 );
|
||||
ImGui::InputFloat3( "Sc", matrixScale, 3 );
|
||||
ImGuizmo::RecomposeMatrixFromComponents( matrixTranslation, matrixRotation, matrixScale, matrix.m16 );
|
||||
|
||||
if( mCurrentGizmoOperation != ImGuizmo::SCALE )
|
||||
{
|
||||
if( ImGui::RadioButton( "Local", mCurrentGizmoMode == ImGuizmo::LOCAL ) )
|
||||
{
|
||||
mCurrentGizmoMode = ImGuizmo::LOCAL;
|
||||
}
|
||||
ImGui::SameLine();
|
||||
if( ImGui::RadioButton( "World", mCurrentGizmoMode == ImGuizmo::WORLD ) )
|
||||
{
|
||||
mCurrentGizmoMode = ImGuizmo::WORLD;
|
||||
}
|
||||
}
|
||||
static bool useSnap( false );
|
||||
if( ImGui::IsKeyPressed( 83 ) )
|
||||
{
|
||||
useSnap = !useSnap;
|
||||
}
|
||||
ImGui::Checkbox( "", &useSnap );
|
||||
ImGui::SameLine();
|
||||
vec_t snap;
|
||||
switch( mCurrentGizmoOperation )
|
||||
{
|
||||
case ImGuizmo::TRANSLATE:
|
||||
snap = config.mSnapTranslation;
|
||||
ImGui::InputFloat3( "Snap", &snap.x );
|
||||
break;
|
||||
case ImGuizmo::ROTATE:
|
||||
snap = config.mSnapRotation;
|
||||
ImGui::InputFloat( "Angle Snap", &snap.x );
|
||||
break;
|
||||
case ImGuizmo::SCALE:
|
||||
snap = config.mSnapScale;
|
||||
ImGui::InputFloat( "Scale Snap", &snap.x );
|
||||
break;
|
||||
}
|
||||
ImGuiIO& io = ImGui::GetIO();
|
||||
ImGuizmo::SetRect( 0, 0, io.DisplaySize.x, io.DisplaySize.y );
|
||||
ImGuizmo::Manipulate( camera.mView.m16, camera.mProjection.m16, mCurrentGizmoOperation, mCurrentGizmoMode, matrix.m16, NULL, useSnap ? &snap.x : NULL );
|
||||
}
|
||||
#endif
|
||||
#pragma once
|
||||
|
||||
#ifdef USE_IMGUI_API
|
||||
#include "imconfig.h"
|
||||
#endif
|
||||
#ifndef IMGUI_API
|
||||
#define IMGUI_API
|
||||
#endif
|
||||
|
||||
#ifndef IMGUIZMO_NAMESPACE
|
||||
#define IMGUIZMO_NAMESPACE ImGuizmo
|
||||
#endif
|
||||
|
||||
namespace IMGUIZMO_NAMESPACE
|
||||
{
|
||||
// call inside your own window and before Manipulate() in order to draw gizmo to that window.
|
||||
// Or pass a specific ImDrawList to draw to (e.g. ImGui::GetForegroundDrawList()).
|
||||
IMGUI_API void SetDrawlist( ImDrawList* drawlist = nullptr );
|
||||
|
||||
// call BeginFrame right after ImGui_XXXX_NewFrame();
|
||||
IMGUI_API void BeginFrame();
|
||||
|
||||
// this is necessary because when imguizmo is compiled into a dll, and imgui into another
|
||||
// globals are not shared between them.
|
||||
// More details at https://stackoverflow.com/questions/19373061/what-happens-to-global-and-static-variables-in-a-shared-library-when-it-is-dynam
|
||||
// expose method to set imgui context
|
||||
IMGUI_API void SetImGuiContext( ImGuiContext* ctx );
|
||||
|
||||
// return true if mouse cursor is over any gizmo control (axis, plan or screen component)
|
||||
IMGUI_API bool IsOver();
|
||||
|
||||
// return true if mouse IsOver or if the gizmo is in moving state
|
||||
IMGUI_API bool IsUsing();
|
||||
|
||||
// return true if any gizmo is in moving state
|
||||
IMGUI_API bool IsUsingAny();
|
||||
|
||||
// enable/disable the gizmo. Stay in the state until next call to Enable.
|
||||
// gizmo is rendered with gray half transparent color when disabled
|
||||
IMGUI_API void Enable( bool enable );
|
||||
|
||||
// helper functions for manualy editing translation/rotation/scale with an input float
|
||||
// translation, rotation and scale float points to 3 floats each
|
||||
// Angles are in degrees (more suitable for human editing)
|
||||
// example:
|
||||
// float matrixTranslation[3], matrixRotation[3], matrixScale[3];
|
||||
// ImGuizmo::DecomposeMatrixToComponents(gizmoMatrix.m16, matrixTranslation, matrixRotation, matrixScale);
|
||||
// ImGui::InputFloat3("Tr", matrixTranslation, 3);
|
||||
// ImGui::InputFloat3("Rt", matrixRotation, 3);
|
||||
// ImGui::InputFloat3("Sc", matrixScale, 3);
|
||||
// ImGuizmo::RecomposeMatrixFromComponents(matrixTranslation, matrixRotation, matrixScale, gizmoMatrix.m16);
|
||||
//
|
||||
// These functions have some numerical stability issues for now. Use with caution.
|
||||
IMGUI_API void DecomposeMatrixToComponents( const float* matrix, float* translation, float* rotation, float* scale );
|
||||
IMGUI_API void RecomposeMatrixFromComponents( const float* translation, const float* rotation, const float* scale, float* matrix );
|
||||
|
||||
IMGUI_API void SetRect( float x, float y, float width, float height );
|
||||
// default is false
|
||||
IMGUI_API void SetOrthographic( bool isOrthographic );
|
||||
|
||||
// Render a cube with face color corresponding to face normal. Usefull for debug/tests
|
||||
IMGUI_API void DrawCubes( const float* view, const float* projection, const float* matrices, int matrixCount );
|
||||
IMGUI_API void DrawGrid( const float* view, const float* projection, const float* matrix, const float gridSize );
|
||||
|
||||
// call it when you want a gizmo
|
||||
// Needs view and projection matrices.
|
||||
// matrix parameter is the source matrix (where will be gizmo be drawn) and might be transformed by the function. Return deltaMatrix is optional
|
||||
// translation is applied in world space
|
||||
enum OPERATION
|
||||
{
|
||||
TRANSLATE_X = ( 1u << 0 ),
|
||||
TRANSLATE_Y = ( 1u << 1 ),
|
||||
TRANSLATE_Z = ( 1u << 2 ),
|
||||
ROTATE_X = ( 1u << 3 ),
|
||||
ROTATE_Y = ( 1u << 4 ),
|
||||
ROTATE_Z = ( 1u << 5 ),
|
||||
ROTATE_SCREEN = ( 1u << 6 ),
|
||||
SCALE_X = ( 1u << 7 ),
|
||||
SCALE_Y = ( 1u << 8 ),
|
||||
SCALE_Z = ( 1u << 9 ),
|
||||
BOUNDS = ( 1u << 10 ),
|
||||
SCALE_XU = ( 1u << 11 ),
|
||||
SCALE_YU = ( 1u << 12 ),
|
||||
SCALE_ZU = ( 1u << 13 ),
|
||||
|
||||
TRANSLATE = TRANSLATE_X | TRANSLATE_Y | TRANSLATE_Z,
|
||||
ROTATE = ROTATE_X | ROTATE_Y | ROTATE_Z | ROTATE_SCREEN,
|
||||
SCALE = SCALE_X | SCALE_Y | SCALE_Z,
|
||||
SCALEU = SCALE_XU | SCALE_YU | SCALE_ZU, // universal
|
||||
UNIVERSAL = TRANSLATE | ROTATE | SCALEU
|
||||
};
|
||||
|
||||
inline OPERATION operator|( OPERATION lhs, OPERATION rhs )
|
||||
{
|
||||
return static_cast<OPERATION>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
|
||||
}
|
||||
|
||||
enum MODE
|
||||
{
|
||||
LOCAL,
|
||||
WORLD
|
||||
};
|
||||
|
||||
IMGUI_API bool Manipulate( const float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float* deltaMatrix = NULL, const float* snap = NULL, const float* localBounds = NULL, const float* boundsSnap = NULL );
|
||||
//
|
||||
// Please note that this cubeview is patented by Autodesk : https://patents.google.com/patent/US7782319B2/en
|
||||
// It seems to be a defensive patent in the US. I don't think it will bring troubles using it as
|
||||
// other software are using the same mechanics. But just in case, you are now warned!
|
||||
//
|
||||
IMGUI_API void ViewManipulate( float* view, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor );
|
||||
|
||||
// use this version if you did not call Manipulate before and you are just using ViewManipulate
|
||||
IMGUI_API void ViewManipulate( float* view, const float* projection, OPERATION operation, MODE mode, float* matrix, float length, ImVec2 position, ImVec2 size, ImU32 backgroundColor );
|
||||
|
||||
IMGUI_API void SetID( int id );
|
||||
|
||||
// return true if the cursor is over the operation's gizmo
|
||||
IMGUI_API bool IsOver( OPERATION op );
|
||||
IMGUI_API void SetGizmoSizeClipSpace( float value );
|
||||
|
||||
// Allow axis to flip
|
||||
// When true (default), the guizmo axis flip for better visibility
|
||||
// When false, they always stay along the positive world/local axis
|
||||
IMGUI_API void AllowAxisFlip( bool value );
|
||||
|
||||
// Configure the limit where axis are hidden
|
||||
IMGUI_API void SetAxisLimit( float value );
|
||||
// Configure the limit where planes are hiden
|
||||
IMGUI_API void SetPlaneLimit( float value );
|
||||
|
||||
enum COLOR
|
||||
{
|
||||
DIRECTION_X, // directionColor[0]
|
||||
DIRECTION_Y, // directionColor[1]
|
||||
DIRECTION_Z, // directionColor[2]
|
||||
PLANE_X, // planeColor[0]
|
||||
PLANE_Y, // planeColor[1]
|
||||
PLANE_Z, // planeColor[2]
|
||||
SELECTION, // selectionColor
|
||||
INACTIVE, // inactiveColor
|
||||
TRANSLATION_LINE, // translationLineColor
|
||||
SCALE_LINE,
|
||||
ROTATION_USING_BORDER,
|
||||
ROTATION_USING_FILL,
|
||||
HATCHED_AXIS_LINES,
|
||||
TEXT,
|
||||
TEXT_SHADOW,
|
||||
COUNT
|
||||
};
|
||||
|
||||
struct Style
|
||||
{
|
||||
IMGUI_API Style();
|
||||
|
||||
float TranslationLineThickness; // Thickness of lines for translation gizmo
|
||||
float TranslationLineArrowSize; // Size of arrow at the end of lines for translation gizmo
|
||||
float RotationLineThickness; // Thickness of lines for rotation gizmo
|
||||
float RotationOuterLineThickness; // Thickness of line surrounding the rotation gizmo
|
||||
float ScaleLineThickness; // Thickness of lines for scale gizmo
|
||||
float ScaleLineCircleSize; // Size of circle at the end of lines for scale gizmo
|
||||
float HatchedAxisLineThickness; // Thickness of hatched axis lines
|
||||
float CenterCircleSize; // Size of circle at the center of the translate/scale gizmo
|
||||
|
||||
ImVec4 Colors[COLOR::COUNT];
|
||||
};
|
||||
|
||||
IMGUI_API Style& GetStyle();
|
||||
}
|
||||
|
|
@ -34,6 +34,7 @@ If you have questions concerning this license or the applicable additional terms
|
|||
#include "LightEditor.h"
|
||||
|
||||
#include "../imgui/BFGimgui.h"
|
||||
#include "../imgui/ImGuizmo.h"
|
||||
|
||||
#include "renderer/Material.h"
|
||||
#include "renderer/Image.h"
|
||||
|
|
@ -574,6 +575,40 @@ static float* vecToArr( idVec3& v )
|
|||
return &v.x;
|
||||
}
|
||||
|
||||
|
||||
void Frustum( float left, float right, float bottom, float top, float znear, float zfar, float* m16 )
|
||||
{
|
||||
float temp, temp2, temp3, temp4;
|
||||
temp = 2.0f * znear;
|
||||
temp2 = right - left;
|
||||
temp3 = top - bottom;
|
||||
temp4 = zfar - znear;
|
||||
m16[0] = temp / temp2;
|
||||
m16[1] = 0.0;
|
||||
m16[2] = 0.0;
|
||||
m16[3] = 0.0;
|
||||
m16[4] = 0.0;
|
||||
m16[5] = temp / temp3;
|
||||
m16[6] = 0.0;
|
||||
m16[7] = 0.0;
|
||||
m16[8] = ( right + left ) / temp2;
|
||||
m16[9] = ( top + bottom ) / temp3;
|
||||
m16[10] = ( -zfar - znear ) / temp4;
|
||||
m16[11] = -1.0f;
|
||||
m16[12] = 0.0;
|
||||
m16[13] = 0.0;
|
||||
m16[14] = ( -temp * zfar ) / temp4;
|
||||
m16[15] = 0.0;
|
||||
}
|
||||
|
||||
void Perspective( float fovyInDegrees, float aspectRatio, float znear, float zfar, float* m16 )
|
||||
{
|
||||
float ymax, xmax;
|
||||
ymax = znear * tanf( fovyInDegrees * 3.141592f / 180.0f );
|
||||
xmax = ymax * aspectRatio;
|
||||
Frustum( -xmax, xmax, -ymax, ymax, znear, zfar, m16 );
|
||||
}
|
||||
|
||||
void LightEditor::Draw()
|
||||
{
|
||||
bool showTool = isShown;
|
||||
|
|
@ -774,6 +809,63 @@ void LightEditor::Draw()
|
|||
{
|
||||
TempApplyChanges();
|
||||
}
|
||||
|
||||
//
|
||||
// GIZMO
|
||||
//
|
||||
//ImGuiIO& io = ImGui::GetIO();
|
||||
ImGuizmo::SetRect( 0, 0, io.DisplaySize.x, io.DisplaySize.y );
|
||||
ImGuizmo::SetOrthographic( false );
|
||||
ImGuizmo::SetDrawlist();
|
||||
|
||||
viewDef_t viewDef;
|
||||
if( gameEdit->PlayerGetRenderView( viewDef.renderView ) )
|
||||
{
|
||||
R_SetupViewMatrix( &viewDef );
|
||||
R_SetupProjectionMatrix( &viewDef, false );
|
||||
|
||||
#if 1
|
||||
float* cameraView = viewDef.worldSpace.modelViewMatrix;
|
||||
float* cameraProjection = viewDef.unjitteredProjectionMatrix;
|
||||
#else
|
||||
float cameraView[16];
|
||||
//memcpy( cameraView, viewDef.worldSpace.modelViewMatrix, sizeof( cameraView ) );
|
||||
|
||||
R_AxisToModelMatrix( viewDef.renderView.viewaxis, viewDef.renderView.vieworg, viewDef.worldSpace.modelViewMatrix );
|
||||
R_MatrixTranspose( viewDef.worldSpace.modelViewMatrix, cameraView );
|
||||
|
||||
float aspectRatio = io.DisplaySize.x / io.DisplaySize.y;
|
||||
|
||||
//float cameraProjection[16];
|
||||
//Perspective( viewDef.renderView.fov_y, aspectRatio, viewDef.renderView.cramZNear, 16000.0f, cameraProjection );
|
||||
|
||||
float* cameraProjection = viewDef.unjitteredProjectionMatrix;
|
||||
#endif
|
||||
|
||||
|
||||
ImGuizmo::DrawGrid( cameraView, cameraProjection, mat4_identity.ToFloatPtr(), 100.f );
|
||||
|
||||
idMat3 scaleMatrix = mat3_identity;
|
||||
scaleMatrix[0][0] = 10;
|
||||
scaleMatrix[1][1] = 10;
|
||||
scaleMatrix[2][2] = 10;
|
||||
idMat4 objectMatrix( scaleMatrix, cur.origin );
|
||||
ImGuizmo::DrawCubes( cameraView, cameraProjection, mat4_identity.ToFloatPtr(), 1 );
|
||||
|
||||
ImGuizmo::OPERATION mCurrentGizmoOperation( ImGuizmo::TRANSLATE );
|
||||
ImGuizmo::MODE mCurrentGizmoMode( ImGuizmo::LOCAL );
|
||||
bool useSnap = false;
|
||||
float snap[3] = { 1.f, 1.f, 1.f };
|
||||
float bounds[] = { -0.5f, -0.5f, -0.5f, 0.5f, 0.5f, 0.5f };
|
||||
float boundsSnap[] = { 0.1f, 0.1f, 0.1f };
|
||||
bool boundSizing = false;
|
||||
bool boundSizingSnap = false;
|
||||
|
||||
ImGuizmo::DrawCubes( cameraView, cameraProjection, &objectMatrix[0][0], 1 );
|
||||
ImGuizmo::Manipulate( cameraView, cameraProjection, mCurrentGizmoOperation, mCurrentGizmoMode, objectMatrix.ToFloatPtr(), NULL, useSnap ? &snap[0] : NULL, boundSizing ? bounds : NULL, boundSizingSnap ? boundsSnap : NULL );
|
||||
|
||||
//ImGuizmo::ViewManipulate( cameraView, camDistance, ImVec2( viewManipulateRight - 128, viewManipulateTop ), ImVec2( 128, 128 ), 0x10101010 );
|
||||
}
|
||||
}
|
||||
ImGui::End();
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue