/*
* DoNextFindBackwardsMisc - search again, based on last string (EVENT_MISC)
*/
vi_rc DoNextFindBackwardsMisc( void )
{
range r;
vi_rc rc;
if( CurrentFile == NULL ) {
// you cant search if theres no file!
return( ERR_NO_FILE );
}
defaultRange( &r );
rc = getFindString( &r, FALSE, TRUE, TRUE );
JumpTo( &r.start );
return( rc );
} /* DoNextFindBackwardsMisc */
/*
* FancyDoFindMisc - an EVENT_MISC version of below
*/
vi_rc FancyDoFindMisc( void )
{
range r;
vi_rc rc;
if( CurrentFile == NULL ) {
// you cant search if theres no file!
return( ERR_NO_FILE );
}
defaultRange( &r );
rc = FancyDoFind( &r, 1L );
if( rc != RANGE_REQUEST_CANCELLED ) {
JumpTo( &r.start );
}
return( rc );
} /* FancyDoFindMisc */
/*
* DoMove - handle a movement command
*/
vi_rc DoMove( event *ev )
{
range range;
vi_rc rc;
int curcol;
int type;
defaultRange( &range );
if( EditFlags.Modeless ) {
rc = ev->alt_rtn.move( &range, GetRepeatCount() );
type = ev->alt_b.type;
} else {
rc = ev->rtn.move( &range, GetRepeatCount() );
type = ev->b.type;
}
if( rc == ERR_NO_ERR ) {
curcol = CurrentPos.column;
if( range.start.line != CurrentPos.line ) {
if( type == EVENT_REL_MOVE ) {
GoToLineRelCurs( range.start.line );
} else {
curcol = -1;
MemorizeCurrentContext();
GoToLineNoRelCurs( range.start.line );
}
}
if( curcol != range.start.column ) {
GoToColumnOK( range.start.column );
}
#ifndef __WIN__
if( range.highlight ) {
// don't handle multi-line highlights yet
assert( range.hi_start.line == range.hi_end.line );
EditFlags.ResetDisplayLine = true;
DCUpdate();
HiliteAColumnRange( range.hi_start.line,
range.hi_start.column, range.hi_end.column );
}
#endif
}
return( rc );
}
/*
* doOperator - process an operator event
*/
static vi_rc doOperator( event *ev )
{
event *next;
vi_rc rc;
long count;
range range;
int next_type;
bool is_op_alias;
rc = ERR_INVALID_OP;
defaultRange( &range );
count = GetRepeatCount();
is_op_alias = ev->b.is_op_alias;
if( is_op_alias ) {
ev->rtn.alias( &ev, &next );
} else {
next = nextEvent();
// a count is the only thing allowed to interfere between an op and
// its argument so we just keep chewing...
if( next != &EventList['0'] ) {
while( next->b.is_number ) {
if( EditFlags.Modeless ) {
next->alt_rtn.old();
} else {
next->rtn.old();
}
next = nextEvent();
}
}
count *= GetRepeatCount();
}
KillRepeatWindow();
if( EditFlags.Modeless ) {
range.fix_range = next->alt_b.fix_range;
next_type = next->alt_b.type;
} else {
range.fix_range = next->b.fix_range;
next_type = next->b.type;
}
EditFlags.OperatorWantsMove = true; // was: if( count==1 )
if( next_type == EVENT_OP ) {
// op/op only valid when ops are equal
if( next == ev ) {
rc = GetLineRange( &range, count, CurrentPos.line );
}
} else {
// it had better be a move operation
if( next_type == EVENT_REL_MOVE || next_type == EVENT_ABS_MOVE ) {
/*
* Kluge! want 'ce' instead of 'cw' - this sucks.
*
* - even better kludge: if we are currently on white
* space, then treat 'cw' as 'cw'. arrrrr. cge.
*/
if( ( ev == &EventList['c'] || ev == &EventList[VI_KEY( ALT_F1 )] ) &&
LastEvent == 'w' ) {
EditFlags.IsChangeWord = true;
if( CurrentLine != NULL ) {
if( !isspace( CurrentLine->data[CurrentPos.column - 1] ) ) {
next = &EventList['e'];
range.fix_range = false;
}
}
}
if( EditFlags.Modeless ) {
rc = next->alt_rtn.move( &range, count );
} else {
rc = next->rtn.move( &range, count );
}
EditFlags.IsChangeWord = false;
} else {
/*
* Kluge! treat 'r' as a movement command.
*/
if( LastEvent == 'r' ) {
rc = GetSelectedRegion( &range );
} else if( LastEvent == '0' ) {
rc = MoveLineBegin( &range, 1 );
} else if( LastEvent == VI_KEY( ESC ) ) {
rc = RANGE_REQUEST_CANCELLED;
}
}
}
EditFlags.OperatorWantsMove = false;
if( rc == ERR_NO_ERR ) {
if( ev->b.modifies ) {
rc = ModificationTest();
}
if( rc == ERR_NO_ERR ) {
NormalizeRange( &range );
if( EditFlags.Modeless ) {
rc = ev->alt_rtn.op( &range );
} else {
rc = ev->rtn.op( &range );
}
}
}
return( rc );
} /* doOperator */
void setShaderUniforms(Shader& shader, const Volume& volume, const std::string& samplerID) {
const StructuredCoordinateTransformer<3>& ct = volume.getCoordinateTransformer();
shader.setUniform(samplerID + ".dataToModel", ct.getDataToModelMatrix());
shader.setUniform(samplerID + ".modelToData", ct.getModelToDataMatrix());
shader.setUniform(samplerID + ".dataToWorld", ct.getDataToWorldMatrix());
shader.setUniform(samplerID + ".worldToData", ct.getWorldToDataMatrix());
shader.setUniform(samplerID + ".modelToWorld", ct.getModelToWorldMatrix());
shader.setUniform(samplerID + ".worldToModel", ct.getWorldToModelMatrix());
shader.setUniform(samplerID + ".worldToTexture", ct.getWorldToTextureMatrix());
shader.setUniform(samplerID + ".textureToWorld", ct.getTextureToWorldMatrix());
auto textureToWorldNormalMatrix = glm::inverseTranspose(ct.getTextureToWorldMatrix());
shader.setUniform(samplerID + ".textureToWorldNormalMatrix", textureToWorldNormalMatrix);
shader.setUniform(samplerID + ".textureToIndex", ct.getTextureToIndexMatrix());
shader.setUniform(samplerID + ".indexToTexture", ct.getIndexToTextureMatrix());
float gradientSpacing = volume.getWorldSpaceGradientSpacing();
// Scale the world matrix by the gradient spacing and the transform it to texture space.
// Note that since we are dealing with real values we can multiply the scalar after the
// transform as well
shader.setUniform(
samplerID + ".textureSpaceGradientSpacing",
gradientSpacing * mat3(ct.getWorldToTextureMatrix()));
vec3 dimF = static_cast<vec3>(volume.getDimensions());
shader.setUniform(samplerID + ".dimensions", dimF);
shader.setUniform(samplerID + ".reciprocalDimensions", vec3(1.f) / dimF);
shader.setUniform(samplerID + ".worldSpaceGradientSpacing", gradientSpacing);
dvec2 dataRange = volume.dataMap_.dataRange;
DataMapper defaultRange(volume.getDataFormat());
double typescale = 1.0 - getGLFormats()->getGLFormat(volume.getDataFormat()->getId()).scaling;
defaultRange.dataRange = defaultRange.dataRange * typescale;
double scalingFactor = 1.0;
double signedScalingFactor = 1.0;
double offset = 0.0;
double signedOffset = 0.0;
double invRange = 1.0 / (dataRange.y - dataRange.x);
double defaultToDataRange = (defaultRange.dataRange.y - defaultRange.dataRange.x) * invRange;
double defaultToDataOffset = (dataRange.x - defaultRange.dataRange.x) /
(defaultRange.dataRange.y - defaultRange.dataRange.x);
switch (getGLFormats()->getGLFormat(volume.getDataFormat()->getId()).normalization) {
case GLFormats::NONE:
scalingFactor = invRange;
offset = -dataRange.x;
signedScalingFactor = scalingFactor;
signedOffset = offset;
break;
case GLFormats::NORMALIZED:
scalingFactor = defaultToDataRange;
offset = -defaultToDataOffset;
signedScalingFactor = scalingFactor;
signedOffset = offset;
break;
case GLFormats::SIGN_NORMALIZED:
scalingFactor = 0.5 * defaultToDataRange;
offset = 1.0 - 2 * defaultToDataOffset;
signedScalingFactor = defaultToDataRange;
signedOffset = -defaultToDataOffset;
break;
}
// offset scaling because of reversed scaling in the shader, i.e. (1 - formatScaling_)
shader.setUniform(samplerID + ".formatScaling", static_cast<float>(1.0 - scalingFactor));
shader.setUniform(samplerID + ".formatOffset", static_cast<float>(offset));
shader.setUniform(samplerID + ".signedFormatScaling",
static_cast<float>(1.0 - signedScalingFactor));
shader.setUniform(samplerID + ".signedFormatOffset", static_cast<float>(signedOffset));
}
